@eliya-oss/agent-slack 0.1.10 → 0.1.12

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@eliya-oss/agent-slack",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Slack context CLI for AI agents.",
   "type": "module",
-  "packageManager": "pnpm@11.9.0",
   "bin": {
     "agent-slack": "dist/main.js",
     "aslk": "dist/main.js"
@@ -17,22 +16,6 @@
     "LICENSE",
     ".agents/cli-api.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "check": "pnpm typecheck && pnpm test:coverage && pnpm build",
-    "changeset": "changeset",
-    "clean": "rm -rf dist coverage",
-    "dev": "tsx src/main.ts",
-    "prepack": "pnpm build",
-    "release:check": "pnpm check && npm pack --dry-run",
-    "agent-slack": "tsx src/main.ts",
-    "aslk": "tsx src/main.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:emulate": "vitest run tests/emulate",
-    "version-packages": "changeset version"
-  },
   "keywords": [
     "slack",
     "cli",
@@ -55,11 +38,30 @@
     "@types/node": "latest",
     "@vitest/coverage-v8": "^4.1.9",
     "emulate": "^0.8.0",
-    "tsx": "latest",
+    "rolldown": "^1.1.4",
     "typescript": "latest",
     "vitest": "latest"
   },
   "engines": {
     "node": ">=22"
+  },
+  "scripts": {
+    "build": "rolldown -c rolldown.config.mjs",
+    "check": "pnpm typecheck && pnpm test:coverage && pnpm build",
+    "changeset": "changeset",
+    "clean": "rm -rf dist coverage",
+    "dev": "rolldown -c rolldown.config.mjs && node dist/main.js",
+    "docs:build": "pnpm --filter docs build",
+    "docs:dev": "pnpm --filter docs dev",
+    "docs:types": "pnpm --filter docs types:check",
+    "release:check": "pnpm check && npm pack --dry-run",
+    "release:publish": "pnpm build && changeset publish",
+    "agent-slack": "rolldown -c rolldown.config.mjs && node dist/main.js",
+    "aslk": "rolldown -c rolldown.config.mjs && node dist/main.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:emulate": "vitest run tests/emulate",
+    "version-packages": "changeset version"
   }
-}
+}

package/dist/adapters/catalog/BundledMethodCatalog.js

@@ -1,53 +0,0 @@
-const methods = [
-    { method: "api.test", family: "api", summary: "Test Slack API reachability.", safety: "read", scopes: [], cursorPaginated: false },
-    { method: "auth.test", family: "auth", summary: "Test authentication.", safety: "read", scopes: [], cursorPaginated: false },
-    { method: "team.info", family: "team", summary: "Workspace info.", safety: "read", scopes: ["team:read"], cursorPaginated: false },
-    { method: "team.profile.get", family: "team", summary: "Workspace profile fields.", safety: "read", scopes: ["users.profile:read"], cursorPaginated: false },
-    { method: "conversations.list", family: "conversations", summary: "List conversations.", safety: "read", scopes: ["channels:read", "groups:read", "im:read", "mpim:read"], itemKey: "channels", cursorPaginated: true },
-    { method: "conversations.info", family: "conversations", summary: "Conversation info.", safety: "read", scopes: ["channels:read", "groups:read", "im:read", "mpim:read"], cursorPaginated: false },
-    { method: "conversations.members", family: "conversations", summary: "Conversation members.", safety: "read", scopes: ["channels:read", "groups:read", "im:read", "mpim:read"], itemKey: "members", cursorPaginated: true },
-    { method: "conversations.history", family: "conversations", summary: "Conversation history.", safety: "read", scopes: ["channels:history", "groups:history", "im:history", "mpim:history"], itemKey: "messages", cursorPaginated: true },
-    { method: "conversations.replies", family: "conversations", summary: "Thread replies.", safety: "read", scopes: ["channels:history", "groups:history", "im:history", "mpim:history"], itemKey: "messages", cursorPaginated: true },
-    { method: "chat.getPermalink", family: "chat", summary: "Message permalink.", safety: "read", scopes: [], cursorPaginated: false },
-    { method: "users.list", family: "users", summary: "List users.", safety: "read", scopes: ["users:read"], itemKey: "members", cursorPaginated: true },
-    { method: "users.info", family: "users", summary: "User info.", safety: "read", scopes: ["users:read"], cursorPaginated: false },
-    { method: "users.lookupByEmail", family: "users", summary: "Find user by email.", safety: "read", scopes: ["users:read.email"], cursorPaginated: false },
-    { method: "users.getPresence", family: "users", summary: "User presence.", safety: "read", scopes: ["users:read"], cursorPaginated: false },
-    { method: "usergroups.list", family: "usergroups", summary: "List user groups.", safety: "read", scopes: ["usergroups:read"], itemKey: "usergroups", cursorPaginated: false },
-    { method: "usergroups.users.list", family: "usergroups", summary: "List users in a user group.", safety: "read", scopes: ["usergroups:read"], itemKey: "users", cursorPaginated: false },
-    { method: "files.list", family: "files", summary: "List files.", safety: "read", scopes: ["files:read"], itemKey: "files", cursorPaginated: true },
-    { method: "files.info", family: "files", summary: "File info.", safety: "read", scopes: ["files:read"], cursorPaginated: false },
-    { method: "reactions.get", family: "reactions", summary: "Message reactions.", safety: "read", scopes: ["reactions:read"], cursorPaginated: false },
-    { method: "pins.list", family: "pins", summary: "Pinned items.", safety: "read", scopes: ["pins:read"], itemKey: "items", cursorPaginated: false },
-    { method: "bookmarks.list", family: "bookmarks", summary: "Channel bookmarks.", safety: "read", scopes: ["bookmarks:read"], itemKey: "bookmarks", cursorPaginated: false },
-    { method: "emoji.list", family: "emoji", summary: "Workspace emoji.", safety: "read", scopes: ["emoji:read"], cursorPaginated: false },
-    { method: "dnd.info", family: "dnd", summary: "DND status.", safety: "read", scopes: ["dnd:read"], cursorPaginated: false },
-    { method: "search.messages", family: "search", summary: "Legacy message search.", safety: "read", scopes: ["search:read.public", "search:read.private"], itemKey: "matches", cursorPaginated: false },
-    { method: "search.files", family: "search", summary: "Legacy file search.", safety: "read", scopes: ["search:read.files"], itemKey: "matches", cursorPaginated: false },
-    { method: "assistant.search.context", family: "assistant", summary: "Real-time Search API context.", safety: "read", scopes: ["search:read.public", "search:read.private"], itemKey: "results", cursorPaginated: false },
-    { method: "chat.postMessage", family: "chat", summary: "Post message.", safety: "write", scopes: ["chat:write"], cursorPaginated: false },
-    { method: "chat.delete", family: "chat", summary: "Delete message.", safety: "destructive", scopes: ["chat:write"], cursorPaginated: false },
-    { method: "files.delete", family: "files", summary: "Delete file.", safety: "destructive", scopes: ["files:write"], cursorPaginated: false }
-];
-const unsafePrefixes = ["admin.", "chat.post", "chat.update", "chat.delete", "files.delete", "conversations.archive", "conversations.kick"];
-export class BundledMethodCatalog {
-    listMethods(family) {
-        return family === undefined ? methods : methods.filter((method) => method.family === family);
-    }
-    describeMethod(method) {
-        return methods.find((item) => item.method === method) ?? null;
-    }
-    safetyFor(method) {
-        const found = this.describeMethod(method);
-        if (found !== null) {
-            return found.safety;
-        }
-        if (unsafePrefixes.some((prefix) => method.startsWith(prefix))) {
-            return method.startsWith("admin.") ? "admin" : "write";
-        }
-        return "unknown";
-    }
-    itemKeyFor(method) {
-        return this.describeMethod(method)?.itemKey ?? null;
-    }
-}

package/dist/adapters/http-file-downloader/HttpFileDownloader.js

@@ -1,20 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { SlackApiFailed } from "../../domain/errors.js";
-export class HttpFileDownloader {
-    async download(input) {
-        const response = await fetch(input.url, {
-            headers: { authorization: `Bearer ${input.token}` }
-        });
-        if (!response.ok) {
-            throw new SlackApiFailed(`Slack file download failed with HTTP ${response.status}`, {
-                status: response.status,
-                url: input.url
-            });
-        }
-        const data = Buffer.from(await response.arrayBuffer());
-        await mkdir(dirname(input.outPath), { recursive: true });
-        await writeFile(input.outPath, data, { mode: 0o600 });
-        return { path: input.outPath, bytes: data.byteLength };
-    }
-}

package/dist/adapters/keychain/KeychainTokenStore.js

@@ -1,152 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
-import { UsageError } from "../../domain/errors.js";
-import { ProfileName, Scope } from "../../domain/ids.js";
-const execFileAsync = promisify(execFile);
-export class KeychainTokenStore {
-    filePath;
-    secrets;
-    constructor(filePath, secrets = new MacOSSecurityKeychainSecrets()) {
-        this.filePath = filePath;
-        this.secrets = secrets;
-    }
-    static fromEnv(env = process.env) {
-        const configDir = env.AGENT_SLACK_CONFIG_DIR ?? env.SLK_CONFIG_DIR ?? join(env.HOME ?? process.cwd(), ".config", "agent-slack");
-        return new KeychainTokenStore(join(configDir, "profiles.keychain.json"));
-    }
-    async getProfile(name) {
-        const stored = (await this.readProfiles()).find((profile) => profile.name === name);
-        return stored === undefined ? null : this.hydrate(stored);
-    }
-    async setProfile(profile) {
-        const profiles = await this.readProfiles();
-        const previous = profiles.find((item) => item.name === profile.name);
-        const stored = await this.dehydrate(profile);
-        await this.deleteRemovedTokenAccounts(previous, stored);
-        await this.writeProfiles([stored, ...profiles.filter((item) => item.name !== profile.name)]);
-    }
-    async listProfiles() {
-        const profiles = await this.readProfiles();
-        return Promise.all(profiles.map((profile) => this.hydrate(profile)));
-    }
-    async deleteProfile(name) {
-        const profiles = await this.readProfiles();
-        const found = profiles.find((profile) => profile.name === name);
-        if (found === undefined) {
-            return false;
-        }
-        await Promise.all(Object.values(found.tokenAccounts).map((account) => account === undefined ? Promise.resolve() : this.secrets.delete(account)));
-        const next = profiles.filter((profile) => profile.name !== name);
-        if (next.length === 0) {
-            await rm(this.filePath, { force: true });
-        }
-        else {
-            await this.writeProfiles(next);
-        }
-        return true;
-    }
-    async dehydrate(profile) {
-        const tokenAccounts = {};
-        for (const field of tokenFields) {
-            const token = profile[field];
-            if (token !== undefined) {
-                const account = accountFor(profile.name, field);
-                await this.secrets.set(account, token);
-                tokenAccounts[field] = account;
-            }
-        }
-        return {
-            name: profile.name,
-            tokenType: profile.tokenType,
-            scopes: profile.scopes,
-            tokenAccounts,
-            ...(profile.teamId === undefined ? {} : { teamId: profile.teamId }),
-            ...(profile.enterpriseId === undefined ? {} : { enterpriseId: profile.enterpriseId }),
-            ...(profile.userId === undefined ? {} : { userId: profile.userId }),
-            ...(profile.botId === undefined ? {} : { botId: profile.botId })
-        };
-    }
-    async hydrate(profile) {
-        const tokens = Object.fromEntries(await Promise.all(tokenFields.map(async (field) => {
-            const account = profile.tokenAccounts[field];
-            return [field, account === undefined ? undefined : await this.secrets.get(account)];
-        })));
-        return {
-            name: ProfileName.make(profile.name),
-            tokenType: profile.tokenType,
-            scopes: profile.scopes.map(Scope.make),
-            ...(profile.teamId === undefined ? {} : { teamId: profile.teamId }),
-            ...(profile.enterpriseId === undefined ? {} : { enterpriseId: profile.enterpriseId }),
-            ...(profile.userId === undefined ? {} : { userId: profile.userId }),
-            ...(profile.botId === undefined ? {} : { botId: profile.botId }),
-            ...(tokens.botToken == null ? {} : { botToken: tokens.botToken }),
-            ...(tokens.userToken == null ? {} : { userToken: tokens.userToken }),
-            ...(tokens.adminToken == null ? {} : { adminToken: tokens.adminToken }),
-            ...(tokens.appToken == null ? {} : { appToken: tokens.appToken })
-        };
-    }
-    async deleteRemovedTokenAccounts(previous, next) {
-        if (previous === undefined) {
-            return;
-        }
-        const nextAccounts = new Set(Object.values(next.tokenAccounts));
-        await Promise.all(Object.values(previous.tokenAccounts).map((account) => {
-            if (account === undefined || nextAccounts.has(account)) {
-                return Promise.resolve();
-            }
-            return this.secrets.delete(account);
-        }));
-    }
-    async readProfiles() {
-        try {
-            const raw = await readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            return parsed.profiles ?? [];
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return [];
-            }
-            throw error;
-        }
-    }
-    async writeProfiles(profiles) {
-        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
-        await writeFile(this.filePath, JSON.stringify({ profiles }, null, 2), { mode: 0o600 });
-    }
-}
-class MacOSSecurityKeychainSecrets {
-    service = "agent-slack";
-    async get(account) {
-        this.assertDarwin();
-        try {
-            const { stdout } = await execFileAsync("security", ["find-generic-password", "-s", this.service, "-a", account, "-w"]);
-            return stdout.trimEnd();
-        }
-        catch {
-            return null;
-        }
-    }
-    async set(account, value) {
-        this.assertDarwin();
-        await execFileAsync("security", ["add-generic-password", "-s", this.service, "-a", account, "-w", value, "-U"]);
-    }
-    async delete(account) {
-        this.assertDarwin();
-        try {
-            await execFileAsync("security", ["delete-generic-password", "-s", this.service, "-a", account]);
-        }
-        catch {
-            // Deleting a missing keychain item is idempotent for TokenStore semantics.
-        }
-    }
-    assertDarwin() {
-        if (process.platform !== "darwin") {
-            throw new UsageError("Keychain token storage is only supported on macOS in this adapter");
-        }
-    }
-}
-const tokenFields = ["botToken", "userToken", "adminToken", "appToken"];
-const accountFor = (profileName, field) => `profile:${profileName}:${field}`;

package/dist/adapters/live.js

@@ -1,17 +0,0 @@
-import { BundledMethodCatalog } from "./catalog/BundledMethodCatalog.js";
-import { HttpFileDownloader } from "./http-file-downloader/HttpFileDownloader.js";
-import { KeychainTokenStore } from "./keychain/KeychainTokenStore.js";
-import { NodeLocalhostOAuthFlow } from "./localhost-oauth/NodeLocalhostOAuthFlow.js";
-import { FileTokenStore } from "./profile-file/FileTokenStore.js";
-import { SlackSdkWebApi } from "./slack-sdk/SlackSdkWebApi.js";
-export const createLiveServices = (env = process.env) => {
-    const tokenStore = env.AGENT_SLACK_TOKEN_STORE ?? env.SLK_TOKEN_STORE;
-    const slackApiUrl = env.AGENT_SLACK_API_BASE_URL ?? env.SLK_SLACK_API_BASE_URL;
-    return {
-        tokenStore: tokenStore === "keychain" ? KeychainTokenStore.fromEnv(env) : FileTokenStore.fromEnv(env),
-        oauthFlow: NodeLocalhostOAuthFlow.fromEnv(env),
-        fileDownloader: new HttpFileDownloader(),
-        slackWebApi: new SlackSdkWebApi(slackApiUrl === undefined ? {} : { slackApiUrl }),
-        methodCatalog: new BundledMethodCatalog()
-    };
-};

package/dist/adapters/localhost-oauth/NodeLocalhostOAuthFlow.js

@@ -1,232 +0,0 @@
-import { createHash, randomBytes } from "node:crypto";
-import { spawn } from "node:child_process";
-import { writeFile } from "node:fs/promises";
-import { createServer } from "node:http";
-import { PermissionDenied, SlackApiFailed, UsageError } from "../../domain/errors.js";
-import { ProfileName, Scope } from "../../domain/ids.js";
-export class NodeLocalhostOAuthFlow {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    static fromEnv(env = process.env) {
-        const apiBaseUrl = env.AGENT_SLACK_API_BASE_URL ?? env.SLK_SLACK_API_BASE_URL;
-        const emulatorBaseUrl = apiBaseUrl?.replace(/\/api\/?$/, "");
-        const redirectHost = env.AGENT_SLACK_OAUTH_REDIRECT_HOST ?? env.SLK_OAUTH_REDIRECT_HOST;
-        const redirectPort = env.AGENT_SLACK_OAUTH_REDIRECT_PORT ?? env.SLK_OAUTH_REDIRECT_PORT;
-        const redirectPath = env.AGENT_SLACK_OAUTH_REDIRECT_PATH ?? env.SLK_OAUTH_REDIRECT_PATH;
-        const slackRedirectUri = env.AGENT_SLACK_OAUTH_REDIRECT_URI ?? env.AGENT_SLACK_OAUTH_PUBLIC_REDIRECT_URI;
-        const localCallbackUri = env.AGENT_SLACK_OAUTH_LOCAL_CALLBACK_URI;
-        const timeoutMs = env.AGENT_SLACK_OAUTH_TIMEOUT_MS ?? env.SLK_OAUTH_TIMEOUT_MS;
-        return new NodeLocalhostOAuthFlow({
-            authorizeUrl: env.AGENT_SLACK_OAUTH_AUTHORIZE_URL ?? env.SLK_SLACK_OAUTH_AUTHORIZE_URL ?? (emulatorBaseUrl === undefined ? "https://slack.com/oauth/v2/authorize" : `${emulatorBaseUrl}/oauth/v2/authorize`),
-            tokenUrl: env.AGENT_SLACK_OAUTH_ACCESS_URL ?? env.SLK_SLACK_OAUTH_ACCESS_URL ?? (apiBaseUrl === undefined ? "https://slack.com/api/oauth.v2.access" : `${apiBaseUrl.replace(/\/?$/, "/")}oauth.v2.access`),
-            ...(slackRedirectUri === undefined ? {} : { defaultSlackRedirectUri: slackRedirectUri }),
-            ...(localCallbackUri === undefined ? {} : { defaultLocalCallbackUri: localCallbackUri }),
-            ...(redirectHost === undefined ? {} : { defaultRedirectHost: redirectHost }),
-            ...(redirectPort === undefined ? {} : { defaultRedirectPort: Number(redirectPort) }),
-            ...(redirectPath === undefined ? {} : { defaultRedirectPath: redirectPath }),
-            ...(timeoutMs === undefined ? {} : { defaultTimeoutMs: Number(timeoutMs) })
-        });
-    }
-    async login(input) {
-        const state = randomBytes(24).toString("base64url");
-        const codeVerifier = input.pkce === true ? randomBytes(32).toString("base64url") : undefined;
-        const timeoutMs = input.timeoutMs ?? this.options.defaultTimeoutMs ?? 120_000;
-        const server = createServer();
-        const slackRedirectUri = input.redirectUri ?? this.options.defaultSlackRedirectUri;
-        const localCallbackUri = input.localCallbackUri ??
-            this.options.defaultLocalCallbackUri ??
-            (slackRedirectUri !== undefined && isLocalCallbackUri(slackRedirectUri) ? slackRedirectUri : undefined);
-        const started = await listen(server, localCallbackUri, {
-            host: this.options.defaultRedirectHost ?? defaultRedirectHost,
-            port: this.options.defaultRedirectPort ?? defaultRedirectPort,
-            path: this.options.defaultRedirectPath ?? "/oauth/slack/callback"
-        });
-        const redirectUri = slackRedirectUri ?? started.redirectUri;
-        const authorizationUrl = buildAuthorizationUrl({
-            authorizeUrl: this.options.authorizeUrl,
-            clientId: input.clientId,
-            redirectUri,
-            scopes: input.scopes,
-            userScopes: input.userScopes,
-            state,
-            ...(codeVerifier === undefined ? {} : { codeChallenge: codeChallengeFor(codeVerifier) })
-        });
-        if (input.authUrlOut !== undefined) {
-            await writeFile(input.authUrlOut, authorizationUrl, "utf8");
-        }
-        else if (input.openBrowser !== false) {
-            const opened = await (this.options.openBrowser ?? openSystemBrowser)(authorizationUrl);
-            process.stderr.write(opened
-                ? `Opening Slack OAuth in your browser.\nIf it did not open, visit:\n${authorizationUrl}\n`
-                : `Could not open a browser automatically. Visit this Slack OAuth URL:\n${authorizationUrl}\n`);
-        }
-        else {
-            process.stderr.write(`Open this Slack OAuth URL:\n${authorizationUrl}\n`);
-        }
-        return await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                closeServer(server);
-                reject(new UsageError("Timed out waiting for Slack OAuth callback", { timeoutMs }));
-            }, timeoutMs);
-            server.on("request", async (request, response) => {
-                try {
-                    const requestUrl = new URL(request.url ?? "/", started.redirectUri);
-                    if (requestUrl.pathname !== started.path) {
-                        response.writeHead(404).end("Not found");
-                        return;
-                    }
-                    if (requestUrl.searchParams.get("state") !== state) {
-                        throw new PermissionDenied("Slack OAuth state mismatch");
-                    }
-                    const code = requestUrl.searchParams.get("code");
-                    const oauthError = requestUrl.searchParams.get("error");
-                    if (oauthError !== null) {
-                        throw new PermissionDenied(`Slack OAuth failed: ${oauthError}`, { slackError: oauthError });
-                    }
-                    if (code === null || code === "") {
-                        throw new UsageError("Slack OAuth callback did not include a code");
-                    }
-                    const access = await exchangeCode({
-                        tokenUrl: this.options.tokenUrl,
-                        code,
-                        clientId: input.clientId,
-                        clientSecret: input.clientSecret,
-                        codeVerifier,
-                        redirectUri
-                    });
-                    const profile = toAuthProfile(input.profileName, access, input.pkce === true ? "user" : "bot");
-                    response.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end("<html><body>Slack auth complete. You can close this tab.</body></html>");
-                    clearTimeout(timer);
-                    closeServer(server);
-                    resolve(profile);
-                }
-                catch (error) {
-                    response.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end(error instanceof Error ? error.message : String(error));
-                    clearTimeout(timer);
-                    closeServer(server);
-                    reject(error);
-                }
-            });
-        });
-    }
-}
-const listen = (server, redirectUri, fallback) => new Promise((resolve, reject) => {
-    const parsed = redirectUri === undefined ? null : new URL(redirectUri);
-    const host = parsed?.hostname ?? fallback.host;
-    const path = parsed?.pathname ?? fallback.path;
-    const port = parsed === null || parsed.port === "" ? fallback.port : Number(parsed.port);
-    if (!Number.isInteger(port) || port < 0) {
-        reject(new UsageError("OAuth redirect URI must include a valid port", { redirectUri }));
-        return;
-    }
-    server.once("error", reject);
-    server.listen(port, host, () => {
-        const address = server.address();
-        const actualPort = parsed === null || parsed.port === "" ? port : address.port;
-        resolve({
-            redirectUri: redirectUri ?? `http://${host}:${actualPort}${path}`,
-            path
-        });
-    });
-});
-const defaultRedirectHost = "localhost";
-const defaultRedirectPort = 45454;
-const isLocalCallbackUri = (value) => {
-    const parsed = new URL(value);
-    return parsed.protocol === "http:" && (parsed.hostname === "localhost" ||
-        parsed.hostname === "127.0.0.1" ||
-        parsed.hostname === "[::1]" ||
-        parsed.hostname === "::1");
-};
-const buildAuthorizationUrl = (input) => {
-    const url = new URL(input.authorizeUrl);
-    url.searchParams.set("client_id", input.clientId);
-    if (input.scopes.length > 0) {
-        url.searchParams.set("scope", input.scopes.join(","));
-    }
-    if (input.userScopes.length > 0) {
-        url.searchParams.set("user_scope", input.userScopes.join(","));
-    }
-    url.searchParams.set("redirect_uri", input.redirectUri);
-    url.searchParams.set("state", input.state);
-    if (input.codeChallenge !== undefined) {
-        url.searchParams.set("code_challenge", input.codeChallenge);
-        url.searchParams.set("code_challenge_method", "S256");
-    }
-    return url.toString();
-};
-const exchangeCode = async (input) => {
-    const requestBody = new URLSearchParams({
-        code: input.code,
-        client_id: input.clientId,
-        redirect_uri: input.redirectUri
-    });
-    if (input.clientSecret !== undefined) {
-        requestBody.set("client_secret", input.clientSecret);
-    }
-    if (input.codeVerifier !== undefined) {
-        requestBody.set("code_verifier", input.codeVerifier);
-    }
-    const response = await fetch(input.tokenUrl, {
-        method: "POST",
-        headers: { "content-type": "application/x-www-form-urlencoded" },
-        body: requestBody
-    });
-    const body = await response.json();
-    if (body.ok === false) {
-        throw new PermissionDenied(`Slack OAuth token exchange failed: ${body.error ?? "unknown_error"}`, {
-            slackError: body.error ?? "unknown_error"
-        });
-    }
-    if (body.access_token === undefined && body.authed_user?.access_token === undefined) {
-        throw new SlackApiFailed("Slack OAuth token exchange did not return a token");
-    }
-    return body;
-};
-const toAuthProfile = (profileName, response, preferredTokenType) => {
-    const botScopes = splitScopes(response.scope);
-    const userScopes = splitScopes(response.authed_user?.scope);
-    const rootTokenIsUser = preferredTokenType === "user" && response.access_token !== undefined && response.token_type !== "bot";
-    const userToken = response.authed_user?.access_token ?? (rootTokenIsUser ? response.access_token : undefined);
-    const useUserToken = preferredTokenType === "user" && userToken !== undefined;
-    const scopes = useUserToken && userScopes.length > 0 ? userScopes : [...botScopes, ...userScopes];
-    return {
-        name: ProfileName.make(profileName),
-        tokenType: useUserToken || response.access_token === undefined ? "user" : "bot",
-        enterpriseId: response.enterprise?.id ?? null,
-        ...(response.team?.id === undefined ? {} : { teamId: response.team.id }),
-        ...(response.authed_user?.id === undefined ? {} : { userId: response.authed_user.id }),
-        ...(response.bot_user_id === undefined ? {} : { botId: response.bot_user_id }),
-        ...(response.access_token === undefined || useUserToken ? {} : { botToken: response.access_token }),
-        ...(userToken === undefined ? {} : { userToken }),
-        scopes: [...new Set(scopes)].map(Scope.make)
-    };
-};
-const codeChallengeFor = (codeVerifier) => createHash("sha256").update(codeVerifier).digest("base64url");
-const splitScopes = (value) => value === undefined || value.trim() === "" ? [] : value.split(",").map((scope) => scope.trim()).filter(Boolean);
-const closeServer = (server) => {
-    server.close();
-};
-const openSystemBrowser = (url) => new Promise((resolve) => {
-    const command = browserCommand(url);
-    const child = spawn(command.file, command.args, {
-        detached: true,
-        stdio: "ignore"
-    });
-    child.once("error", () => resolve(false));
-    child.once("spawn", () => {
-        child.unref();
-        resolve(true);
-    });
-});
-const browserCommand = (url) => {
-    if (process.platform === "darwin") {
-        return { file: "open", args: [url] };
-    }
-    if (process.platform === "win32") {
-        return { file: "cmd", args: ["/c", "start", "", url] };
-    }
-    return { file: "xdg-open", args: [url] };
-};

package/dist/adapters/profile-file/FileTokenStore.js

@@ -1,67 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { ProfileName, Scope } from "../../domain/ids.js";
-export class FileTokenStore {
-    filePath;
-    envProfile;
-    constructor(filePath, envProfile = null) {
-        this.filePath = filePath;
-        this.envProfile = envProfile;
-    }
-    static fromEnv(env = process.env) {
-        const configDir = env.AGENT_SLACK_CONFIG_DIR ?? env.SLK_CONFIG_DIR ?? join(env.HOME ?? process.cwd(), ".config", "agent-slack");
-        const token = env.AGENT_SLACK_TOKEN ?? env.SLK_TOKEN ?? env.SLACK_BOT_TOKEN ?? null;
-        const envProfile = token === null
-            ? null
-            : {
-                name: ProfileName.default,
-                tokenType: "bot",
-                botToken: token,
-                scopes: (env.AGENT_SLACK_SCOPES ?? env.SLK_SCOPES ?? "").split(",").filter(Boolean).map(Scope.make)
-            };
-        return new FileTokenStore(join(configDir, "profiles.json"), envProfile);
-    }
-    async getProfile(name) {
-        const profiles = await this.readProfiles();
-        return profiles.find((profile) => profile.name === name) ?? (name === "default" ? this.envProfile : null);
-    }
-    async setProfile(profile) {
-        const profiles = await this.readProfiles();
-        const next = [profile, ...profiles.filter((item) => item.name !== profile.name)];
-        await this.writeProfiles(next);
-    }
-    async listProfiles() {
-        const profiles = await this.readProfiles();
-        return this.envProfile === null ? profiles : [this.envProfile, ...profiles.filter((item) => item.name !== this.envProfile?.name)];
-    }
-    async deleteProfile(name) {
-        const profiles = await this.readProfiles();
-        const next = profiles.filter((profile) => profile.name !== name);
-        if (next.length === profiles.length) {
-            return false;
-        }
-        if (next.length === 0) {
-            await rm(this.filePath, { force: true });
-            return true;
-        }
-        await this.writeProfiles(next);
-        return true;
-    }
-    async readProfiles() {
-        try {
-            const raw = await readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            return parsed.profiles ?? [];
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return [];
-            }
-            throw error;
-        }
-    }
-    async writeProfiles(profiles) {
-        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
-        await writeFile(this.filePath, JSON.stringify({ profiles }, null, 2), { mode: 0o600 });
-    }
-}

package/dist/adapters/slack-sdk/SlackSdkWebApi.js

@@ -1,48 +0,0 @@
-import { WebClient } from "@slack/web-api";
-import { MissingScope, PermissionDenied, SlackApiFailed, SlackRateLimited } from "../../domain/errors.js";
-export class SlackSdkWebApi {
-    options;
-    constructor(options = {}) {
-        this.options = options;
-    }
-    async call(input) {
-        const client = new WebClient(input.token, {
-            ...(this.options.slackApiUrl === undefined ? {} : { slackApiUrl: this.options.slackApiUrl }),
-            allowAbsoluteUrls: false
-        });
-        try {
-            const response = await client.apiCall(input.method, input.payload);
-            const record = response;
-            if (record.ok === false) {
-                throw slackError(input.method, record);
-            }
-            return { method: input.method, response: record };
-        }
-        catch (error) {
-            if (error instanceof SlackApiFailed || error instanceof MissingScope || error instanceof PermissionDenied || error instanceof SlackRateLimited) {
-                throw error;
-            }
-            const maybe = error;
-            if (maybe.code === "slack_webapi_rate_limited") {
-                throw new SlackRateLimited("Slack rate limit reached", maybe.retryAfter === undefined ? {} : { retryAfterSeconds: maybe.retryAfter });
-            }
-            if (maybe.code === "slack_webapi_platform_error" && maybe.data !== undefined) {
-                throw slackError(input.method, maybe.data);
-            }
-            throw new SlackApiFailed(`Slack method failed: ${input.method}`, { method: input.method, cause: error instanceof Error ? error.message : String(error) });
-        }
-    }
-}
-const slackError = (method, response) => {
-    const slackErrorText = typeof response.error === "string" ? response.error : "unknown_error";
-    if (slackErrorText === "missing_scope") {
-        throw new MissingScope("Slack method is missing required scope", { method, slackError: slackErrorText, response });
-    }
-    if (slackErrorText === "invalid_auth" || slackErrorText === "not_authed" || slackErrorText === "account_inactive") {
-        throw new PermissionDenied("Slack authentication failed", { method, slackError: slackErrorText });
-    }
-    if (slackErrorText === "ratelimited") {
-        throw new SlackRateLimited("Slack rate limit reached", { method, slackError: slackErrorText });
-    }
-    throw new SlackApiFailed(`Slack method returned ${slackErrorText}`, { method, slackError: slackErrorText, response });
-};