@eliya-oss/agent-slack 0.1.11 → 0.1.12

package/dist/application/execute.js

@@ -1,36 +0,0 @@
-import { flagBoolean, flagString, parseArgs } from "../cli/args.js";
-import { errorEnvelope, serializeJson } from "../output/envelope.js";
-import { renderHumanErrorEnvelope } from "../output/human.js";
-import { dispatch, renderDispatchResult } from "./commands.js";
-export const executeCli = async (argv, services, options = {}) => {
-    let parsed = null;
-    try {
-        parsed = parseArgs(argv);
-        const result = await dispatch(parsed, services);
-        return {
-            exitCode: 0,
-            stdout: renderDispatchResult(parsed, result, options),
-            stderr: ""
-        };
-    }
-    catch (error) {
-        const { envelope, exitCode } = errorEnvelope(error);
-        const pretty = parsed === null ? argv.includes("--pretty") : flagBoolean(parsed, "pretty");
-        const stderr = shouldRenderJsonError(argv, parsed, options)
-            ? serializeJson(envelope, pretty)
-            : renderHumanErrorEnvelope(envelope, {
-                color: shouldColorError(argv, parsed, options)
-            });
-        return {
-            exitCode,
-            stdout: "",
-            stderr
-        };
-    }
-};
-const shouldRenderJsonError = (argv, parsed, options) => parsed === null
-    ? argv.includes("--json") || options.stdoutIsTty !== true
-    : flagBoolean(parsed, "json") || flagString(parsed, "format") === "json" || options.stdoutIsTty !== true;
-const shouldColorError = (argv, parsed, options) => options.stdoutIsTty === true &&
-    options.env?.NO_COLOR === undefined &&
-    (parsed === null ? !argv.includes("--no-color") : !flagBoolean(parsed, "no-color"));

package/dist/application/payload.js

@@ -1,40 +0,0 @@
-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

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

package/dist/application/slack-call.js

@@ -1,62 +0,0 @@
-import { UnsafeMethodBlocked } from "../domain/errors.js";
-import { pagingFrom } from "../output/envelope.js";
-export const callSlack = async (services, options) => {
-    const safety = services.methodCatalog.safetyFor(options.method);
-    if (isUnsafe(safety) && (!options.allowWrite || !options.yes)) {
-        throw new UnsafeMethodBlocked(`Refusing unsafe Slack method ${options.method}`, {
-            method: options.method,
-            safety
-        });
-    }
-    if (!options.all) {
-        const result = await services.slackWebApi.call({
-            method: options.method,
-            token: options.token,
-            payload: options.payload
-        });
-        return {
-            method: options.method,
-            response: result.response,
-            items: extractItems(services, options.method, result.response)
-        };
-    }
-    const itemKey = services.methodCatalog.itemKeyFor(options.method);
-    const collected = [];
-    let cursor;
-    let lastResponse = {};
-    for (let page = 0; page < 100; page += 1) {
-        const payload = cursor === undefined ? options.payload : { ...options.payload, cursor };
-        const result = await services.slackWebApi.call({
-            method: options.method,
-            token: options.token,
-            payload
-        });
-        lastResponse = result.response;
-        collected.push(...extractItems(services, options.method, result.response));
-        const paging = pagingFrom(result.response);
-        if (paging.next_cursor === null || itemKey === null) {
-            break;
-        }
-        cursor = paging.next_cursor;
-    }
-    return {
-        method: options.method,
-        response: itemKey === null ? lastResponse : { ...lastResponse, [itemKey]: collected },
-        items: collected
-    };
-};
-const isUnsafe = (safety) => safety === "write" || safety === "destructive" || safety === "admin";
-const extractItems = (services, method, response) => {
-    const itemKey = services.methodCatalog.itemKeyFor(method);
-    if (itemKey === null) {
-        return [];
-    }
-    const value = response[itemKey];
-    if (Array.isArray(value)) {
-        return value;
-    }
-    if (value !== undefined && typeof value === "object" && value !== null) {
-        return Object.entries(value).map(([key, entry]) => ({ key, value: entry }));
-    }
-    return [];
-};

package/dist/cli/args.js

@@ -1,74 +0,0 @@
-import { UsageError } from "../domain/errors.js";
-const booleanFlags = new Set([
-    "all",
-    "allow-write",
-    "help",
-    "json",
-    "no-color",
-    "raw",
-    "pretty",
-    "full",
-    "trace",
-    "yes",
-    "no-cache",
-    "inclusive",
-    "oauth",
-    "no-open"
-]);
-export const parseArgs = (argv) => {
-    const flags = new Map();
-    const positionals = [];
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (token === undefined) {
-            continue;
-        }
-        if (token === "--") {
-            positionals.push(...argv.slice(index + 1));
-            break;
-        }
-        if (!token.startsWith("--") || token === "-") {
-            positionals.push(token);
-            continue;
-        }
-        const raw = token.slice(2);
-        const eq = raw.indexOf("=");
-        const name = eq >= 0 ? raw.slice(0, eq) : raw;
-        if (name === "") {
-            throw new UsageError("Invalid empty flag");
-        }
-        if (eq >= 0) {
-            flags.set(name, raw.slice(eq + 1));
-            continue;
-        }
-        if (booleanFlags.has(name)) {
-            flags.set(name, true);
-            continue;
-        }
-        const value = argv[index + 1];
-        if (value === undefined || value.startsWith("--")) {
-            throw new UsageError(`Missing value for --${name}`, { flag: name });
-        }
-        flags.set(name, value);
-        index += 1;
-    }
-    return { tokens: argv, flags, positionals };
-};
-export const flagString = (parsed, name, fallback) => {
-    const value = parsed.flags.get(name);
-    if (typeof value === "string") {
-        return value;
-    }
-    return fallback;
-};
-export const flagBoolean = (parsed, name) => parsed.flags.get(name) === true;
-export const requireFlag = (parsed, name) => {
-    const value = flagString(parsed, name);
-    if (value === undefined) {
-        throw new UsageError(`Missing required --${name}`, { flag: name });
-    }
-    return value;
-};
-export const splitCsv = (value) => value === undefined || value.trim() === ""
-    ? []
-    : value.split(",").map((item) => item.trim()).filter(Boolean);

package/dist/cli/metadata.js

@@ -1,374 +0,0 @@
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const packageJson = require("../../package.json");
-export const PRIMARY_COMMAND_NAME = "agent-slack";
-export const SHORT_COMMAND_NAME = "aslk";
-export const COMMAND_NAMES = [PRIMARY_COMMAND_NAME, SHORT_COMMAND_NAME];
-export const CLI_VERSION = packageJson.version ?? "0.0.0";
-export const commandMetadata = [
-    {
-        path: ["describe"],
-        summary: "Print the full command catalog as JSON.",
-        flags: ["--json"],
-        safety: "read",
-        output: "command metadata",
-        examples: ["agent-slack describe --json"]
-    },
-    {
-        path: ["completion"],
-        summary: "Generate a shell completion script.",
-        args: ["bash|zsh"],
-        safety: "read",
-        output: "shell completion script",
-        examples: ["agent-slack completion zsh > ~/.zfunc/_agent-slack"]
-    },
-    {
-        path: ["auth", "status"],
-        summary: "Show the active Slack profile.",
-        flags: ["--profile", "--json"],
-        safety: "read",
-        output: "profile status",
-        examples: ["agent-slack auth status --json"]
-    },
-    {
-        path: ["auth", "login"],
-        summary: "Connect a Slack workspace profile.",
-        flags: ["--profile", "--oauth", "--client-id", "--client-secret", "--scopes", "--user-scopes", "--redirect-uri", "--auth-url-out", "--timeout-ms", "--no-open", "--token", "--json"],
-        safety: "read",
-        output: "profile status",
-        examples: [
-            "agent-slack auth login --json",
-            "AGENT_SLACK_TOKEN=xoxb-... agent-slack auth login --profile work --scopes channels:read --json",
-            "agent-slack auth login --oauth --client-id 123.456 --client-secret secret --scopes channels:read,channels:history --json",
-        ]
-    },
-    {
-        path: ["auth", "scopes"],
-        summary: "Show scopes granted to the active profile.",
-        flags: ["--profile", "--json"],
-        safety: "read",
-        output: "scope list",
-        examples: ["agent-slack auth scopes --json"]
-    },
-    {
-        path: ["auth", "profiles", "list"],
-        summary: "List local Slack profiles.",
-        flags: ["--json"],
-        safety: "read",
-        output: "profile list",
-        examples: ["agent-slack auth profiles list --json"]
-    },
-    {
-        path: ["auth", "logout"],
-        summary: "Delete a local Slack profile.",
-        flags: ["--profile", "--json"],
-        safety: "destructive",
-        output: "deleted profile status",
-        examples: ["agent-slack auth logout --profile work --yes --json"]
-    },
-    {
-        path: ["auth", "test"],
-        summary: "Test the active Slack profile.",
-        methods: ["auth.test"],
-        scopes: [],
-        safety: "read",
-        output: "Slack auth.test response",
-        examples: ["agent-slack auth test --json"]
-    },
-    {
-        path: ["team", "get"],
-        summary: "Show Slack workspace details.",
-        methods: ["team.info"],
-        scopes: ["team:read"],
-        safety: "read",
-        output: "team info",
-        examples: ["agent-slack team get --json"]
-    },
-    {
-        path: ["team", "profile", "get"],
-        summary: "Show workspace profile fields.",
-        methods: ["team.profile.get"],
-        scopes: ["users.profile:read"],
-        safety: "read",
-        output: "team profile fields",
-        examples: ["agent-slack team profile get --json"]
-    },
-    {
-        path: ["enterprise", "get"],
-        summary: "Show enterprise and workspace identity.",
-        methods: ["team.info"],
-        scopes: ["team:read"],
-        safety: "read",
-        output: "team or enterprise info",
-        examples: ["agent-slack enterprise get --json"]
-    },
-    {
-        path: ["user", "list"],
-        summary: "List users visible to the active profile.",
-        flags: ["--limit", "--all", "--json"],
-        methods: ["users.list"],
-        scopes: ["users:read"],
-        safety: "read",
-        output: "user list",
-        examples: ["agent-slack user list --limit 50 --json"]
-    },
-    {
-        path: ["user", "get"],
-        summary: "Show one user.",
-        args: ["USER_ID"],
-        methods: ["users.info"],
-        scopes: ["users:read"],
-        safety: "read",
-        output: "user info",
-        examples: ["agent-slack user get U123 --json"]
-    },
-    {
-        path: ["user", "lookup"],
-        summary: "Find a user by email.",
-        flags: ["--email", "--json"],
-        methods: ["users.lookupByEmail"],
-        scopes: ["users:read.email"],
-        safety: "read",
-        output: "user info",
-        examples: ["agent-slack user lookup --email dev@example.com --json"]
-    },
-    {
-        path: ["user", "presence", "get"],
-        summary: "Show user presence.",
-        args: ["USER_ID"],
-        methods: ["users.getPresence"],
-        scopes: ["users:read"],
-        safety: "read",
-        output: "presence",
-        examples: ["agent-slack user presence get U123 --json"]
-    },
-    {
-        path: ["usergroups", "list"],
-        summary: "List Slack user groups.",
-        methods: ["usergroups.list"],
-        scopes: ["usergroups:read"],
-        safety: "read",
-        output: "user group list",
-        examples: ["agent-slack usergroups list --json"]
-    },
-    {
-        path: ["usergroups", "users", "list"],
-        summary: "List users in a Slack user group.",
-        args: ["USERGROUP_ID"],
-        methods: ["usergroups.users.list"],
-        scopes: ["usergroups:read"],
-        safety: "read",
-        output: "user IDs",
-        examples: ["agent-slack usergroups users list S123 --json"]
-    },
-    {
-        path: ["api", "call"],
-        summary: "Call a Slack Web API method with a JSON payload.",
-        args: ["METHOD", "PAYLOAD_STDIN_MARKER"],
-        flags: ["--payload", "--profile", "--token", "--all", "--raw", "--format", "--allow-write", "--yes", "--json"],
-        safety: "unknown",
-        output: "Slack Web API response",
-        examples: [
-            "agent-slack api call conversations.history --payload '{\"channel\":\"C123\"}' --json",
-            "cat payload.json | agent-slack api call conversations.history -"
-        ]
-    },
-    {
-        path: ["api", "methods", "list"],
-        summary: "List bundled Slack Web API metadata.",
-        flags: ["--family", "--json"],
-        safety: "read",
-        output: "method metadata list",
-        examples: ["agent-slack api methods list --family conversations --json"]
-    },
-    {
-        path: ["api", "method", "describe"],
-        summary: "Describe one Slack method.",
-        args: ["METHOD"],
-        flags: ["--json"],
-        safety: "read",
-        output: "method metadata",
-        examples: ["agent-slack api method describe conversations.replies --json"]
-    },
-    {
-        path: ["conversation", "list"],
-        summary: "List conversations visible to the active profile.",
-        methods: ["conversations.list"],
-        scopes: ["channels:read", "groups:read", "im:read", "mpim:read"],
-        safety: "read",
-        output: "conversation list",
-        examples: ["agent-slack conversation list --types public_channel,private_channel --json"]
-    },
-    {
-        path: ["conversation", "history"],
-        summary: "Read conversation history.",
-        args: ["CHANNEL_ID"],
-        methods: ["conversations.history"],
-        scopes: ["channels:history", "groups:history", "im:history", "mpim:history"],
-        safety: "read",
-        output: "message list",
-        examples: ["agent-slack conversation history C123 --limit 20 --json"]
-    },
-    {
-        path: ["conversation", "context"],
-        summary: "Build channel context for agents.",
-        args: ["CHANNEL_ID"],
-        methods: ["conversations.history", "conversations.replies", "users.info"],
-        scopes: ["channels:history", "users:read"],
-        safety: "read",
-        output: "hydrated conversation context",
-        examples: ["agent-slack conversation context C123 --since 24h --include users,threads --format ndjson"]
-    },
-    {
-        path: ["thread", "get"],
-        summary: "Read a complete Slack thread.",
-        flags: ["--channel", "--ts", "--include", "--json"],
-        methods: ["conversations.replies"],
-        scopes: ["channels:history", "groups:history", "im:history", "mpim:history"],
-        safety: "read",
-        output: "thread messages",
-        examples: ["agent-slack thread get --channel C123 --ts 1710000000.000100 --include users --json"]
-    },
-    {
-        path: ["message", "get"],
-        summary: "Read one Slack message by channel and timestamp.",
-        flags: ["--channel", "--ts", "--json"],
-        methods: ["conversations.history"],
-        scopes: ["channels:history"],
-        safety: "read",
-        output: "message",
-        examples: ["agent-slack message get --channel C123 --ts 1710000000.000100 --json"]
-    },
-    {
-        path: ["message", "permalink"],
-        summary: "Get a Slack permalink for a message.",
-        flags: ["--channel", "--ts", "--json"],
-        methods: ["chat.getPermalink"],
-        safety: "read",
-        output: "permalink",
-        examples: ["agent-slack message permalink --channel C123 --ts 1710000000.000100 --json"]
-    },
-    {
-        path: ["search", "context"],
-        summary: "Search Slack for relevant context.",
-        flags: ["--query", "--content-types", "--json"],
-        methods: ["assistant.search.context"],
-        scopes: ["search:read.public", "search:read.private"],
-        safety: "read",
-        output: "search context",
-        examples: ["agent-slack search context --query 'project atlas' --json"]
-    },
-    {
-        path: ["file", "list"],
-        summary: "List files visible to the active profile.",
-        methods: ["files.list"],
-        scopes: ["files:read"],
-        safety: "read",
-        output: "file list",
-        examples: ["agent-slack file list --channel C123 --json"]
-    },
-    {
-        path: ["file", "download"],
-        summary: "Download a Slack file to disk.",
-        args: ["FILE_ID"],
-        flags: ["--out", "--profile", "--token", "--json"],
-        methods: ["files.info"],
-        scopes: ["files:read"],
-        safety: "read",
-        output: "download status",
-        examples: ["agent-slack file download F123 --out ./artifact.pdf --json"]
-    }
-];
-export const describeAllCommands = () => ({
-    name: PRIMARY_COMMAND_NAME,
-    aliases: [SHORT_COMMAND_NAME],
-    version: CLI_VERSION,
-    commands: commandMetadata
-});
-export const findCommandMetadata = (path) => commandMetadata.find((command) => command.path.join(" ") === path.join(" ")) ?? null;
-export const describeCommandGroup = (group) => ({
-    name: group,
-    commands: commandMetadata.filter((command) => command.path[0] === group)
-});
-export const renderHumanHelp = (path) => {
-    if (path.join(" ") === "auth login") {
-        return renderAuthLoginHelp();
-    }
-    const command = findCommandMetadata(path);
-    if (command !== null) {
-        return [
-            `${PRIMARY_COMMAND_NAME} ${command.path.join(" ")}`,
-            "",
-            command.summary,
-            "",
-            command.args === undefined ? "" : `Usage: ${PRIMARY_COMMAND_NAME} ${command.path.join(" ")} ${command.args.join(" ")}`,
-            command.scopes === undefined ? "" : `Scopes: ${command.scopes.join(", ")}`,
-            "",
-            "Examples:",
-            ...command.examples.map((example) => `  ${example}`)
-        ].filter((line) => line !== "").join("\n") + "\n";
-    }
-    const commands = path.length === 0 ? commandMetadata : commandMetadata.filter((item) => item.path[0] === path[0]);
-    return [
-        PRIMARY_COMMAND_NAME,
-        "",
-        "Slack context CLI for agents.",
-        "",
-        "Commands:",
-        ...commands.map((item) => `  ${item.path.join(" ").padEnd(28)} ${item.summary}`)
-    ].join("\n") + "\n";
-};
-const renderAuthLoginHelp = () => [
-    "agent-slack auth login",
-    "",
-    "Connect a Slack workspace profile.",
-    "",
-    "Browser login",
-    "  agent-slack auth login",
-    "",
-    "  Opens Slack in the browser and stores a local Slack profile.",
-    "",
-    "Headless setup",
-    "  agent-slack auth login --token \"$SLACK_BOT_TOKEN\" --scopes channels:read,channels:history,users:read",
-    "",
-    "  Stores an existing bot token as a local Slack profile.",
-    "",
-    "Development and self-hosted OAuth",
-    "  agent-slack auth login --oauth --client-id \"$SLACK_CLIENT_ID\" --client-secret \"$SLACK_CLIENT_SECRET\"",
-    "",
-    "Options",
-    "  --profile NAME          Save as a named profile.",
-    "  --token TOKEN           Store an existing Slack bot token.",
-    "  --scopes LIST           Scopes to request or record.",
-    "  --user-scopes LIST      User scopes to request during OAuth.",
-    "  --oauth                 Use Slack OAuth with app credentials.",
-    "  --client-id VALUE       Override the Slack app Client ID.",
-    "  --client-secret VALUE   Slack app Client Secret.",
-    "  --no-open               Print OAuth URL instead of opening the browser.",
-    "  --auth-url-out PATH     Write OAuth URL for headless flows.",
-    "  --json                  Emit machine-readable JSON.",
-    "",
-    "Notes",
-    "  Browser login uses PKCE with Agent Slack's public Slack app.",
-    "  App credentials are for development and self-hosted setups.",
-    ""
-].join("\n");
-export const renderCompletion = (shell) => {
-    const words = [...new Set(commandMetadata.flatMap((command) => command.path))];
-    const commandWords = commandMetadata.map((command) => command.path.join(" "));
-    if (shell === "bash") {
-        return `complete -W '${words.join(" ")}' ${COMMAND_NAMES.join(" ")}\n`;
-    }
-    if (shell === "zsh") {
-        return [
-            `#compdef ${COMMAND_NAMES.join(" ")}`,
-            "_agent_slack_commands=(",
-            ...commandWords.map((command) => `  '${command}:${summaryFor(command)}'`),
-            ")",
-            `_describe '${PRIMARY_COMMAND_NAME} command' _agent_slack_commands`,
-            ""
-        ].join("\n");
-    }
-    return "";
-};
-const summaryFor = (path) => commandMetadata.find((command) => command.path.join(" ") === path)?.summary.replace(/'/g, "") ?? "";

package/dist/cli/types.js

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

package/dist/domain/errors.js

@@ -1,68 +0,0 @@
-export class TaggedSlkError extends Error {
-    details;
-    constructor(message, details = {}) {
-        super(message);
-        this.name = new.target.name;
-        this.details = details;
-    }
-}
-export class NotAuthenticated extends TaggedSlkError {
-    _tag = "NotAuthenticated";
-    exitCode = 4;
-}
-export class MissingScope extends TaggedSlkError {
-    _tag = "MissingScope";
-    exitCode = 4;
-}
-export class PermissionDenied extends TaggedSlkError {
-    _tag = "PermissionDenied";
-    exitCode = 4;
-}
-export class SlackRateLimited extends TaggedSlkError {
-    _tag = "SlackRateLimited";
-    exitCode = 6;
-    retryAfterSeconds;
-    constructor(message, details = {}) {
-        super(message, details);
-        this.retryAfterSeconds = details.retryAfterSeconds;
-    }
-}
-export class SlackApiFailed extends TaggedSlkError {
-    _tag = "SlackApiFailed";
-    exitCode = 1;
-    slackError;
-    constructor(message, details = {}) {
-        super(message, details);
-        this.slackError = details.slackError;
-    }
-}
-export class InvalidPayload extends TaggedSlkError {
-    _tag = "InvalidPayload";
-    exitCode = 2;
-}
-export class ResourceNotFound extends TaggedSlkError {
-    _tag = "ResourceNotFound";
-    exitCode = 3;
-}
-export class UnsafeMethodBlocked extends TaggedSlkError {
-    _tag = "UnsafeMethodBlocked";
-    exitCode = 5;
-}
-export class UsageError extends TaggedSlkError {
-    _tag = "UsageError";
-    exitCode = 2;
-}
-export class UnsupportedMethod extends TaggedSlkError {
-    _tag = "UnsupportedMethod";
-    exitCode = 2;
-}
-export const isSlkError = (error) => error instanceof TaggedSlkError;
-export const normalizeUnknownError = (error) => {
-    if (isSlkError(error)) {
-        return error;
-    }
-    if (error instanceof Error) {
-        return new SlackApiFailed(error.message, { cause: error.name });
-    }
-    return new SlackApiFailed("Unexpected failure", { cause: String(error) });
-};