@eliya-oss/agent-slack 0.1.0

package/dist/application/commands.js

@@ -0,0 +1,579 @@
+import { flagBoolean, flagString, requireFlag, splitCsv } from "../cli/args.js";
+import { describeAllCommands, describeCommandGroup, findCommandMetadata, renderCompletion, renderHumanHelp } from "../cli/metadata.js";
+import { NotAuthenticated, ResourceNotFound, UnsupportedMethod, UsageError } from "../domain/errors.js";
+import { ProfileName, Scope } from "../domain/ids.js";
+import { pagingFrom, successEnvelope, toNdjson } from "../output/envelope.js";
+import { projectFields } from "../output/projection.js";
+import { getProfile, parseTokenType, requireYes, tokenFor } from "./auth.js";
+import { parseJsonPayload, requirePositional } from "./payload.js";
+import { callSlack } from "./slack-call.js";
+export const dispatch = async (parsed, services) => {
+    const pos = parsed.positionals;
+    const [first, second, third] = pos;
+    if (flagBoolean(parsed, "help") && !flagBoolean(parsed, "json")) {
+        return {
+            method: "help",
+            profile: null,
+            stdoutValue: null,
+            rawStdout: renderHumanHelp(pos)
+        };
+    }
+    if (pos.length === 0 || first === "describe") {
+        return {
+            method: "describe",
+            profile: null,
+            stdoutValue: describeAllCommands()
+        };
+    }
+    if (first === "completion") {
+        const shell = requirePositional(pos, 1, "SHELL");
+        const completion = renderCompletion(shell);
+        if (completion === "") {
+            throw new UsageError("Unsupported completion shell", { shell });
+        }
+        return {
+            method: "completion",
+            profile: null,
+            stdoutValue: null,
+            rawStdout: completion
+        };
+    }
+    if (flagBoolean(parsed, "help") && flagBoolean(parsed, "json")) {
+        return describePath(pos, null);
+    }
+    if (second === "describe") {
+        return describePath(first === undefined ? [] : [first], null);
+    }
+    if (first === "api") {
+        if (second === "methods" && third === "list") {
+            const family = flagString(parsed, "family");
+            return { method: "api.methods.list", profile: null, stdoutValue: services.methodCatalog.listMethods(family) };
+        }
+        if (second === "method" && third === "describe") {
+            const method = requirePositional(pos, 3, "METHOD");
+            const described = services.methodCatalog.describeMethod(method);
+            if (described === null) {
+                throw new UnsupportedMethod(`No bundled metadata for ${method}`, { method });
+            }
+            return { method: "api.method.describe", profile: null, stdoutValue: described };
+        }
+        if (second === "call") {
+            return apiCall(parsed, services);
+        }
+    }
+    if (first === "auth") {
+        return authCommand(parsed, services);
+    }
+    if (first === "team") {
+        return teamCommand(parsed, services);
+    }
+    if (first === "enterprise" && second === "get") {
+        return methodCall(parsed, services, { method: "team.info", payload: {} });
+    }
+    if (first === "user") {
+        return userCommand(parsed, services);
+    }
+    if (first === "usergroups") {
+        return usergroupsCommand(parsed, services);
+    }
+    if (first === "conversation") {
+        return conversationCommand(parsed, services);
+    }
+    if (first === "thread" && second === "get") {
+        return methodCall(parsed, services, {
+            method: "conversations.replies",
+            payload: {
+                channel: requireFlag(parsed, "channel"),
+                ts: requireFlag(parsed, "ts"),
+                limit: numberFlag(parsed, "limit")
+            }
+        });
+    }
+    if (first === "message") {
+        if (second === "get") {
+            const ts = requireFlag(parsed, "ts");
+            return methodCall(parsed, services, {
+                method: "conversations.history",
+                payload: {
+                    channel: requireFlag(parsed, "channel"),
+                    latest: ts,
+                    oldest: ts,
+                    inclusive: true,
+                    limit: 1
+                }
+            });
+        }
+        if (second === "permalink") {
+            return methodCall(parsed, services, {
+                method: "chat.getPermalink",
+                payload: { channel: requireFlag(parsed, "channel"), message_ts: requireFlag(parsed, "ts") }
+            });
+        }
+    }
+    if (first === "search") {
+        return searchCommand(parsed, services);
+    }
+    if (first === "file") {
+        return fileCommand(parsed, services);
+    }
+    if (first === "reaction" && second === "get") {
+        return methodCall(parsed, services, {
+            method: "reactions.get",
+            payload: { channel: requireFlag(parsed, "channel"), timestamp: requireFlag(parsed, "ts") }
+        });
+    }
+    if (first === "pin" && second === "list") {
+        return methodCall(parsed, services, {
+            method: "pins.list",
+            payload: { channel: requirePositional(pos, 2, "CHANNEL_ID") }
+        });
+    }
+    if (first === "bookmark" && second === "list") {
+        return methodCall(parsed, services, {
+            method: "bookmarks.list",
+            payload: { channel_id: requirePositional(pos, 2, "CHANNEL_ID") }
+        });
+    }
+    if (first === "emoji" && second === "list") {
+        return methodCall(parsed, services, { method: "emoji.list", payload: {} });
+    }
+    if (first === "dnd" && second === "status") {
+        return methodCall(parsed, services, {
+            method: "dnd.info",
+            payload: pos[2] === undefined ? {} : { user: pos[2] }
+        });
+    }
+    return describePath(pos, new UsageError(`Unknown command: ${pos.join(" ")}`, { command: pos.join(" ") }));
+};
+const describePath = (path, error) => {
+    const metadata = findCommandMetadata(path);
+    const value = metadata ?? describeCommandGroup(path[0] ?? "slk");
+    if (error !== null && metadata === null) {
+        throw error;
+    }
+    return { method: "describe", profile: null, stdoutValue: value };
+};
+const authCommand = async (parsed, services) => {
+    const pos = parsed.positionals;
+    const profileName = flagString(parsed, "profile", "default") ?? "default";
+    const second = pos[1];
+    if (second === "profiles" && pos[2] === "list") {
+        return {
+            method: "auth.profiles.list",
+            profile: null,
+            stdoutValue: sanitizeProfiles(await services.tokenStore.listProfiles())
+        };
+    }
+    if (second === "logout") {
+        requireYes({ yes: flagBoolean(parsed, "yes"), message: "Refusing to delete auth profile without --yes" });
+        return {
+            method: "auth.logout",
+            profile: null,
+            stdoutValue: { deleted: await services.tokenStore.deleteProfile(profileName), profile: profileName }
+        };
+    }
+    if (second === "status" || second === "scopes") {
+        const profile = await getProfile(services, profileName);
+        return {
+            method: `auth.${second}`,
+            profile,
+            stdoutValue: second === "scopes" ? { scopes: profile.scopes } : sanitizeProfile(profile)
+        };
+    }
+    if (second === "test") {
+        return methodCall(parsed, services, { method: "auth.test", payload: {} });
+    }
+    if (second === "login") {
+        const token = flagString(parsed, "token") ?? process.env.SLK_TOKEN ?? process.env.SLACK_BOT_TOKEN;
+        if (token !== undefined && !flagBoolean(parsed, "oauth")) {
+            const profile = {
+                name: ProfileName.make(profileName),
+                tokenType: "bot",
+                botToken: token,
+                scopes: splitCsv(flagString(parsed, "scopes")).map(Scope.make)
+            };
+            await services.tokenStore.setProfile(profile);
+            return { method: "auth.login", profile, stdoutValue: sanitizeProfile(profile) };
+        }
+        const clientId = flagString(parsed, "client-id") ?? process.env.SLK_CLIENT_ID;
+        const clientSecret = flagString(parsed, "client-secret") ?? process.env.SLK_CLIENT_SECRET;
+        if (clientId === undefined || clientSecret === undefined) {
+            throw new NotAuthenticated("OAuth login needs --client-id/--client-secret or SLK_CLIENT_ID/SLK_CLIENT_SECRET");
+        }
+        const scopes = splitCsv(flagString(parsed, "scopes"));
+        const profile = await services.oauthFlow.login({
+            profileName,
+            clientId,
+            clientSecret,
+            scopes: scopes.length === 0 ? defaultOAuthScopes : scopes,
+            userScopes: splitCsv(flagString(parsed, "user-scopes")),
+            redirectUri: flagString(parsed, "redirect-uri"),
+            authUrlOut: flagString(parsed, "auth-url-out"),
+            timeoutMs: numberFlag(parsed, "timeout-ms")
+        });
+        await services.tokenStore.setProfile(profile);
+        return { method: "auth.login", profile, stdoutValue: sanitizeProfile(profile) };
+    }
+    throw new UsageError("Unknown auth command", { command: pos.join(" ") });
+};
+const defaultOAuthScopes = [
+    "channels:read",
+    "channels:history",
+    "groups:read",
+    "groups:history",
+    "im:read",
+    "im:history",
+    "mpim:read",
+    "mpim:history",
+    "users:read",
+    "files:read",
+    "reactions:read",
+    "pins:read",
+    "bookmarks:read",
+    "team:read"
+];
+const apiCall = async (parsed, services) => {
+    const method = requirePositional(parsed.positionals, 2, "METHOD");
+    const payload = await parseJsonPayload({
+        inline: flagString(parsed, "payload"),
+        positional: parsed.positionals[3]
+    });
+    return methodCall(parsed, services, { method, payload });
+};
+const teamCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    if (second === "get") {
+        return methodCall(parsed, services, { method: "team.info", payload: {} });
+    }
+    if (second === "profile" && parsed.positionals[2] === "get") {
+        return methodCall(parsed, services, { method: "team.profile.get", payload: {} });
+    }
+    throw new UsageError("Unknown team command", { command: parsed.positionals.join(" ") });
+};
+const userCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    if (second === "list") {
+        return methodCall(parsed, services, { method: "users.list", payload: { limit: numberFlag(parsed, "limit") } });
+    }
+    if (second === "get") {
+        return methodCall(parsed, services, { method: "users.info", payload: { user: requirePositional(parsed.positionals, 2, "USER_ID") } });
+    }
+    if (second === "lookup") {
+        return methodCall(parsed, services, { method: "users.lookupByEmail", payload: { email: requireFlag(parsed, "email") } });
+    }
+    if (second === "presence" && parsed.positionals[2] === "get") {
+        return methodCall(parsed, services, { method: "users.getPresence", payload: { user: requirePositional(parsed.positionals, 3, "USER_ID") } });
+    }
+    throw new UsageError("Unknown user command", { command: parsed.positionals.join(" ") });
+};
+const usergroupsCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    if (second === "list") {
+        return methodCall(parsed, services, { method: "usergroups.list", payload: {} });
+    }
+    if (second === "users" && parsed.positionals[2] === "list") {
+        return methodCall(parsed, services, {
+            method: "usergroups.users.list",
+            payload: { usergroup: requirePositional(parsed.positionals, 3, "USERGROUP_ID") }
+        });
+    }
+    throw new UsageError("Unknown usergroups command", { command: parsed.positionals.join(" ") });
+};
+const conversationCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    if (second === "list") {
+        return methodCall(parsed, services, {
+            method: "conversations.list",
+            payload: {
+                types: flagString(parsed, "types", "public_channel,private_channel,mpim,im"),
+                exclude_archived: true,
+                limit: numberFlag(parsed, "limit")
+            }
+        });
+    }
+    if (second === "get") {
+        return methodCall(parsed, services, {
+            method: "conversations.info",
+            payload: { channel: requirePositional(parsed.positionals, 2, "CHANNEL_ID") }
+        });
+    }
+    if (second === "members") {
+        return methodCall(parsed, services, {
+            method: "conversations.members",
+            payload: { channel: requirePositional(parsed.positionals, 2, "CHANNEL_ID"), limit: numberFlag(parsed, "limit") }
+        });
+    }
+    if (second === "context") {
+        return conversationContext(parsed, services);
+    }
+    if (second === "history") {
+        const channel = requirePositional(parsed.positionals, 2, "CHANNEL_ID");
+        return methodCall(parsed, services, {
+            method: "conversations.history",
+            payload: {
+                channel,
+                oldest: flagString(parsed, "oldest") ?? sinceToOldest(flagString(parsed, "since")),
+                latest: flagString(parsed, "latest"),
+                inclusive: flagBoolean(parsed, "inclusive"),
+                limit: numberFlag(parsed, "limit")
+            }
+        });
+    }
+    throw new UsageError("Unknown conversation command", { command: parsed.positionals.join(" ") });
+};
+const conversationContext = async (parsed, services) => {
+    const channel = requirePositional(parsed.positionals, 2, "CHANNEL_ID");
+    const profileName = flagString(parsed, "profile", "default") ?? "default";
+    const tokenType = parseTokenType(flagString(parsed, "token"));
+    const profile = await getProfile(services, profileName);
+    const token = tokenFor(profile, tokenType);
+    const include = new Set(splitCsv(flagString(parsed, "include")));
+    const history = await callSlack(services, {
+        method: "conversations.history",
+        payload: cleanObject({
+            channel,
+            oldest: flagString(parsed, "oldest") ?? sinceToOldest(flagString(parsed, "since")),
+            latest: flagString(parsed, "latest"),
+            inclusive: flagBoolean(parsed, "inclusive"),
+            limit: numberFlag(parsed, "limit")
+        }),
+        token,
+        profile,
+        all: flagBoolean(parsed, "all"),
+        allowWrite: false,
+        yes: false
+    });
+    const messages = extractArray(history.response.messages);
+    const context = {
+        channel,
+        messages
+    };
+    if (include.has("users")) {
+        const users = {};
+        for (const userId of uniqueStrings(messages.map((message) => stringField(extractLooseRecord(message), "user")))) {
+            const user = await callSlack(services, {
+                method: "users.info",
+                payload: { user: userId },
+                token,
+                profile,
+                all: false,
+                allowWrite: false,
+                yes: false
+            });
+            users[userId] = user.response.user ?? user.response;
+        }
+        context.users = users;
+    }
+    if (include.has("permalinks")) {
+        const permalinks = {};
+        for (const ts of uniqueStrings(messages.map((message) => stringField(extractLooseRecord(message), "ts")))) {
+            const permalink = await callSlack(services, {
+                method: "chat.getPermalink",
+                payload: { channel, message_ts: ts },
+                token,
+                profile,
+                all: false,
+                allowWrite: false,
+                yes: false
+            });
+            const value = stringField(permalink.response, "permalink");
+            if (value !== undefined) {
+                permalinks[ts] = value;
+            }
+        }
+        context.permalinks = permalinks;
+    }
+    if (include.has("threads")) {
+        const threads = {};
+        for (const message of messages) {
+            const record = extractLooseRecord(message);
+            const ts = stringField(record, "thread_ts") ?? stringField(record, "ts");
+            const hasReplies = typeof record.reply_count === "number" && record.reply_count > 0;
+            if (ts !== undefined && hasReplies) {
+                const thread = await callSlack(services, {
+                    method: "conversations.replies",
+                    payload: { channel, ts },
+                    token,
+                    profile,
+                    all: false,
+                    allowWrite: false,
+                    yes: false
+                });
+                threads[ts] = thread.response.messages ?? thread.response;
+            }
+        }
+        context.threads = threads;
+    }
+    return {
+        method: "conversation.context",
+        profile,
+        response: history.response,
+        stdoutValue: context,
+        items: messages
+    };
+};
+const searchCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    const query = requireFlag(parsed, "query");
+    if (second === "context") {
+        return methodCall(parsed, services, {
+            method: "assistant.search.context",
+            payload: { query, content_types: splitCsv(flagString(parsed, "content-types")) }
+        });
+    }
+    if (second === "messages") {
+        return methodCall(parsed, services, { method: "search.messages", payload: { query } });
+    }
+    if (second === "files") {
+        return methodCall(parsed, services, { method: "search.files", payload: { query } });
+    }
+    throw new UsageError("Unknown search command", { command: parsed.positionals.join(" ") });
+};
+const fileCommand = async (parsed, services) => {
+    const second = parsed.positionals[1];
+    if (second === "list") {
+        return methodCall(parsed, services, {
+            method: "files.list",
+            payload: {
+                channel: flagString(parsed, "channel"),
+                user: flagString(parsed, "user"),
+                count: numberFlag(parsed, "limit")
+            }
+        });
+    }
+    if (second === "get") {
+        return methodCall(parsed, services, { method: "files.info", payload: { file: requirePositional(parsed.positionals, 2, "FILE_ID") } });
+    }
+    if (second === "download") {
+        return fileDownload(parsed, services);
+    }
+    throw new UsageError("Unknown file command", { command: parsed.positionals.join(" ") });
+};
+const fileDownload = async (parsed, services) => {
+    const profileName = flagString(parsed, "profile", "default") ?? "default";
+    const tokenType = parseTokenType(flagString(parsed, "token"));
+    const profile = await getProfile(services, profileName);
+    const token = tokenFor(profile, tokenType);
+    const fileId = requirePositional(parsed.positionals, 2, "FILE_ID");
+    const outPath = requireFlag(parsed, "out");
+    const result = await callSlack(services, {
+        method: "files.info",
+        payload: { file: fileId },
+        token,
+        profile,
+        all: false,
+        allowWrite: false,
+        yes: false
+    });
+    const file = extractRecord(result.response.file);
+    const url = stringField(file, "url_private_download") ?? stringField(file, "url_private");
+    if (url === undefined) {
+        throw new ResourceNotFound("Slack file metadata did not include a private download URL", { file: fileId });
+    }
+    const download = await services.fileDownloader.download({ url, token, outPath });
+    return {
+        method: "file.download",
+        profile,
+        response: result.response,
+        stdoutValue: { file, download }
+    };
+};
+const methodCall = async (parsed, services, input) => {
+    const profileName = flagString(parsed, "profile", "default") ?? "default";
+    const tokenType = parseTokenType(flagString(parsed, "token"));
+    const profile = await getProfile(services, profileName);
+    const token = tokenFor(profile, tokenType);
+    const cleanPayload = Object.fromEntries(Object.entries(input.payload).filter(([, value]) => value !== undefined && value !== ""));
+    const result = await callSlack(services, {
+        method: input.method,
+        payload: cleanPayload,
+        token,
+        profile,
+        all: flagBoolean(parsed, "all"),
+        allowWrite: flagBoolean(parsed, "allow-write"),
+        yes: flagBoolean(parsed, "yes")
+    });
+    if (flagBoolean(parsed, "raw")) {
+        return {
+            method: input.method,
+            profile,
+            stdoutValue: result.response,
+            rawStdout: `${JSON.stringify(result.response, null, 2)}\n`,
+            response: result.response,
+            items: result.items
+        };
+    }
+    return {
+        method: input.method,
+        profile,
+        stdoutValue: result.response,
+        response: result.response,
+        items: result.items
+    };
+};
+export const renderDispatchResult = (parsed, result) => {
+    if (result.rawStdout !== undefined) {
+        return result.rawStdout;
+    }
+    if (flagString(parsed, "format") === "ndjson") {
+        return toNdjson(result.items ?? []);
+    }
+    const data = projectFields(result.stdoutValue, flagString(parsed, "fields"));
+    const envelope = successEnvelope({
+        method: result.method,
+        profile: result.profile,
+        data,
+        ...(result.response === undefined ? {} : { paging: pagingFrom(result.response) }),
+        ...(result.warnings === undefined ? {} : { warnings: result.warnings })
+    });
+    return `${JSON.stringify(envelope, null, 2)}\n`;
+};
+const numberFlag = (parsed, name) => {
+    const value = flagString(parsed, name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsedNumber = Number(value);
+    if (!Number.isInteger(parsedNumber) || parsedNumber < 1) {
+        throw new UsageError(`--${name} must be a positive integer`, { flag: name, value });
+    }
+    return parsedNumber;
+};
+const sinceToOldest = (since) => {
+    if (since === undefined) {
+        return undefined;
+    }
+    const match = since.match(/^(\d+)([hd])$/);
+    if (match === null) {
+        return undefined;
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const seconds = unit === "h" ? amount * 60 * 60 : amount * 24 * 60 * 60;
+    return String(Math.floor(Date.now() / 1000) - seconds);
+};
+const cleanObject = (input) => Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== ""));
+const sanitizeProfiles = (profiles) => profiles.map(sanitizeProfile);
+const sanitizeProfile = (profile) => ({
+    name: profile.name,
+    teamId: profile.teamId ?? null,
+    enterpriseId: profile.enterpriseId ?? null,
+    userId: profile.userId ?? null,
+    botId: profile.botId ?? null,
+    tokenType: profile.tokenType,
+    scopes: profile.scopes,
+    hasBotToken: profile.botToken !== undefined,
+    hasUserToken: profile.userToken !== undefined,
+    hasAdminToken: profile.adminToken !== undefined,
+    hasAppToken: profile.appToken !== undefined
+});
+const extractRecord = (value) => {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    throw new ResourceNotFound("Slack response did not include a file object");
+};
+const stringField = (record, name) => typeof record[name] === "string" && record[name].length > 0 ? record[name] : undefined;
+const extractArray = (value) => Array.isArray(value) ? value : [];
+const extractLooseRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+const uniqueStrings = (values) => [...new Set(values.filter((value) => value !== undefined))];

package/dist/application/execute.js

@@ -0,0 +1,22 @@
+import { parseArgs } from "../cli/args.js";
+import { errorEnvelope } from "../output/envelope.js";
+import { dispatch, renderDispatchResult } from "./commands.js";
+export const executeCli = async (argv, services) => {
+    try {
+        const parsed = parseArgs(argv);
+        const result = await dispatch(parsed, services);
+        return {
+            exitCode: 0,
+            stdout: renderDispatchResult(parsed, result),
+            stderr: ""
+        };
+    }
+    catch (error) {
+        const { envelope, exitCode } = errorEnvelope(error);
+        return {
+            exitCode,
+            stdout: "",
+            stderr: `${JSON.stringify(envelope, null, 2)}\n`
+        };
+    }
+};

package/dist/application/payload.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import { InvalidPayload, UsageError } from "../domain/errors.js";
+export const readStdin = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+};
+export const parseJsonPayload = async (input) => {
+    const source = input.inline ?? input.positional;
+    if (source === undefined) {
+        return {};
+    }
+    const raw = source === "-"
+        ? await readStdin()
+        : source.startsWith("@")
+            ? await readFile(source.slice(1), "utf8")
+            : source;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new InvalidPayload("Payload JSON must be an object");
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof InvalidPayload) {
+            throw error;
+        }
+        throw new InvalidPayload("Invalid JSON payload", { source: source === "-" ? "stdin" : source });
+    }
+};
+export const requirePositional = (positionals, index, label) => {
+    const value = positionals[index];
+    if (value === undefined) {
+        throw new UsageError(`Missing ${label}`, { argument: label });
+    }
+    return value;
+};

package/dist/application/services.js

@@ -0,0 +1 @@
+export {};