@urugus/slack-cli 0.1.0

package/src/types/commands.ts

@@ -0,0 +1,46 @@
+export interface ConfigSetOptions {
+  token: string;
+  profile?: string;
+}
+
+export interface ConfigGetOptions {
+  profile?: string;
+}
+
+export interface ConfigUseOptions {
+  profile: string;
+}
+
+export interface ConfigClearOptions {
+  profile?: string;
+}
+
+export interface SendOptions {
+  channel: string;
+  message?: string;
+  file?: string;
+  profile?: string;
+}
+
+export interface ChannelsOptions {
+  type: 'public' | 'private' | 'im' | 'mpim' | 'all';
+  includeArchived: boolean;
+  format: 'table' | 'simple' | 'json';
+  limit: string;
+  profile?: string;
+}
+
+export interface HistoryOptions {
+  channel: string;
+  number?: string;
+  since?: string;
+  profile?: string;
+}
+
+export interface UnreadOptions {
+  channel?: string;
+  format?: 'table' | 'simple' | 'json';
+  countOnly?: boolean;
+  limit?: string;
+  profile?: string;
+}

package/src/types/config.ts

@@ -0,0 +1,20 @@
+export interface Config {
+  token: string;
+  updatedAt: string;
+}
+
+export interface Profile {
+  name: string;
+  config: Config;
+  isDefault?: boolean;
+}
+
+export interface ConfigStore {
+  profiles: Record<string, Config>;
+  defaultProfile?: string;
+}
+
+export interface ConfigOptions {
+  configDir?: string;
+  profile?: string;
+}

package/src/utils/channel-formatter.ts

@@ -0,0 +1,89 @@
+import { Channel } from './slack-api-client';
+import { formatUnixTimestamp } from './date-utils';
+
+export interface ChannelInfo {
+  id: string;
+  name: string;
+  type: string;
+  members: number;
+  created: string;
+  purpose: string;
+}
+
+export function mapChannelToInfo(channel: Channel): ChannelInfo {
+  let type = 'unknown';
+  if (channel.is_channel && !channel.is_private) type = 'public';
+  else if (channel.is_group || (channel.is_channel && channel.is_private)) type = 'private';
+  else if (channel.is_im) type = 'im';
+  else if (channel.is_mpim) type = 'mpim';
+
+  return {
+    id: channel.id,
+    name: channel.name || 'unnamed',
+    type,
+    members: channel.num_members || 0,
+    created: formatUnixTimestamp(channel.created),
+    purpose: channel.purpose?.value || '',
+  };
+}
+
+export function formatChannelsAsTable(channels: ChannelInfo[]): void {
+  // Print table header
+  console.log('Name              Type      Members  Created      Description');
+  console.log('─'.repeat(65));
+
+  // Print channel rows
+  channels.forEach((channel) => {
+    const name = channel.name.padEnd(17);
+    const type = channel.type.padEnd(9);
+    const members = channel.members.toString().padEnd(8);
+    const created = channel.created.padEnd(12);
+    const purpose =
+      channel.purpose.length > 30 ? channel.purpose.substring(0, 27) + '...' : channel.purpose;
+
+    console.log(`${name} ${type} ${members} ${created} ${purpose}`);
+  });
+}
+
+export function formatChannelsAsSimple(channels: ChannelInfo[]): void {
+  channels.forEach((channel) => console.log(channel.name));
+}
+
+export function formatChannelsAsJson(channels: ChannelInfo[]): void {
+  console.log(
+    JSON.stringify(
+      channels.map((channel) => ({
+        id: channel.id,
+        name: channel.name,
+        type: channel.type,
+        members: channel.members,
+        created: channel.created + 'T00:00:00Z',
+        purpose: channel.purpose,
+      })),
+      null,
+      2
+    )
+  );
+}
+
+export function formatChannelName(channelName?: string): string {
+  if (!channelName) return '#unknown';
+  return channelName.startsWith('#') ? channelName : `#${channelName}`;
+}
+
+export function getChannelTypes(type: string): string {
+  switch (type) {
+    case 'public':
+      return 'public_channel';
+    case 'private':
+      return 'private_channel';
+    case 'im':
+      return 'im';
+    case 'mpim':
+      return 'mpim';
+    case 'all':
+      return 'public_channel,private_channel,mpim,im';
+    default:
+      return 'public_channel';
+  }
+}

package/src/utils/client-factory.ts

@@ -0,0 +1,10 @@
+import { SlackApiClient } from './slack-api-client';
+import { getConfigOrThrow } from './config-helper';
+
+/**
+ * Creates a SlackApiClient instance with configuration from the specified profile
+ */
+export async function createSlackClient(profile?: string): Promise<SlackApiClient> {
+  const config = await getConfigOrThrow(profile);
+  return new SlackApiClient(config.token);
+}

package/src/utils/command-wrapper.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { extractErrorMessage } from './error-utils';
+
+export type CommandAction<T = unknown> = (options: T) => Promise<void> | void;
+
+export function wrapCommand<T = unknown>(action: CommandAction<T>): CommandAction<T> {
+  return async (options: T) => {
+    try {
+      await action(options);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), extractErrorMessage(error));
+
+      if (process.env.NODE_ENV === 'development' && error instanceof Error) {
+        console.error(chalk.gray(error.stack));
+      }
+
+      process.exit(1);
+    }
+  };
+}
+
+export async function getProfileName(
+  configManager: { getCurrentProfile: () => Promise<string> },
+  providedProfile?: string
+): Promise<string> {
+  return providedProfile || (await configManager.getCurrentProfile());
+}

package/src/utils/config-helper.ts

@@ -0,0 +1,21 @@
+import { ProfileConfigManager } from './profile-config';
+import { ConfigurationError } from './errors';
+import { ERROR_MESSAGES } from './constants';
+
+/**
+ * Helper function to get configuration with proper error handling
+ */
+export async function getConfigOrThrow(
+  profile?: string,
+  configManager: ProfileConfigManager = new ProfileConfigManager()
+): Promise<{ token: string }> {
+  const config = await configManager.getConfig(profile);
+
+  if (!config) {
+    const profiles = await configManager.listProfiles();
+    const profileName = profile || profiles.find((p) => p.isDefault)?.name || 'default';
+    throw new ConfigurationError(ERROR_MESSAGES.NO_CONFIG(profileName));
+  }
+
+  return config;
+}

package/src/utils/constants.ts

@@ -0,0 +1,47 @@
+export const TOKEN_MASK_LENGTH = 4;
+export const TOKEN_MIN_LENGTH = 9;
+export const DEFAULT_PROFILE_NAME = 'default';
+
+export const ERROR_MESSAGES = {
+  // Configuration errors
+  NO_CONFIG: (profileName: string) =>
+    `No configuration found for profile "${profileName}". Use "slack-cli config set --token <token> --profile ${profileName}" to set up.`,
+  PROFILE_NOT_FOUND: (profileName: string) => `Profile "${profileName}" not found`,
+  NO_PROFILES_FOUND: 'No profiles found. Use "slack-cli config set --token <token>" to create one.',
+  INVALID_CONFIG_FORMAT: 'Invalid config file format',
+
+  // Validation errors
+  NO_MESSAGE_OR_FILE: 'You must specify either --message or --file',
+  BOTH_MESSAGE_AND_FILE: 'Cannot use both --message and --file',
+
+  // API errors
+  API_ERROR: (error: string) => `API Error: ${error}`,
+  CHANNEL_NOT_FOUND: (channel: string) => `Channel not found: ${channel}`,
+
+  // File errors
+  FILE_READ_ERROR: (file: string, error: string) => `Error reading file ${file}: ${error}`,
+  FILE_NOT_FOUND: (file: string) => `File not found: ${file}`,
+
+  // Channels command errors
+  NO_CHANNELS_FOUND: 'No channels found',
+  ERROR_LISTING_CHANNELS: (error: string) => `Error listing channels: ${error}`,
+} as const;
+
+export const SUCCESS_MESSAGES = {
+  TOKEN_SAVED: (profileName: string) => `Token saved successfully for profile "${profileName}"`,
+  PROFILE_SWITCHED: (profileName: string) => `Switched to profile "${profileName}"`,
+  PROFILE_CLEARED: (profileName: string) => `Profile "${profileName}" cleared successfully`,
+  MESSAGE_SENT: (channel: string) => `Message sent successfully to #${channel}`,
+} as const;
+
+// File and system constants
+export const FILE_PERMISSIONS = {
+  CONFIG_FILE: 0o600, // Read/write for owner only
+};
+
+// API limits
+export const API_LIMITS = {
+  MAX_MESSAGE_COUNT: 1000,
+  MIN_MESSAGE_COUNT: 1,
+  DEFAULT_MESSAGE_COUNT: 10,
+};

package/src/utils/date-utils.ts

@@ -0,0 +1,8 @@
+export function formatUnixTimestamp(timestamp: number): string {
+  return new Date(timestamp * 1000).toISOString().split('T')[0];
+}
+
+export function formatSlackTimestamp(slackTimestamp: string): string {
+  const timestamp = parseFloat(slackTimestamp);
+  return new Date(timestamp * 1000).toLocaleString();
+}

package/src/utils/error-utils.ts

@@ -0,0 +1,6 @@
+export function extractErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}

package/src/utils/errors.ts

@@ -0,0 +1,37 @@
+export class SlackCliError extends Error {
+  constructor(
+    message: string,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'SlackCliError';
+  }
+}
+
+export class ConfigurationError extends SlackCliError {
+  constructor(message: string) {
+    super(message, 'CONFIGURATION_ERROR');
+    this.name = 'ConfigurationError';
+  }
+}
+
+export class ValidationError extends SlackCliError {
+  constructor(message: string) {
+    super(message, 'VALIDATION_ERROR');
+    this.name = 'ValidationError';
+  }
+}
+
+export class ApiError extends SlackCliError {
+  constructor(message: string) {
+    super(message, 'API_ERROR');
+    this.name = 'ApiError';
+  }
+}
+
+export class FileError extends SlackCliError {
+  constructor(message: string) {
+    super(message, 'FILE_ERROR');
+    this.name = 'FileError';
+  }
+}

package/src/utils/profile-config.ts

@@ -0,0 +1,171 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import type { Config, ConfigOptions, ConfigStore, Profile } from '../types/config';
+import {
+  TOKEN_MASK_LENGTH,
+  TOKEN_MIN_LENGTH,
+  DEFAULT_PROFILE_NAME,
+  ERROR_MESSAGES,
+  FILE_PERMISSIONS,
+} from './constants';
+
+export class ProfileConfigManager {
+  private configPath: string;
+
+  constructor(options: ConfigOptions = {}) {
+    const configDir = options.configDir || path.join(os.homedir(), '.slack-cli');
+    this.configPath = path.join(configDir, 'config.json');
+  }
+
+  async setToken(token: string, profile?: string): Promise<void> {
+    const store = await this.getConfigStore();
+    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
+    const config: Config = {
+      token,
+      updatedAt: new Date().toISOString(),
+    };
+
+    store.profiles[profileName] = config;
+
+    // Set as default profile if it's the first one or explicitly setting default
+    if (!store.defaultProfile || profileName === DEFAULT_PROFILE_NAME) {
+      store.defaultProfile = profileName;
+    }
+
+    await this.saveConfigStore(store);
+  }
+
+  async getConfig(profile?: string): Promise<Config | null> {
+    const store = await this.getConfigStore();
+    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
+
+    return store.profiles[profileName] || null;
+  }
+
+  async listProfiles(): Promise<Profile[]> {
+    const store = await this.getConfigStore();
+    const currentProfile = store.defaultProfile || DEFAULT_PROFILE_NAME;
+
+    return Object.entries(store.profiles).map(([name, config]) => ({
+      name,
+      config,
+      isDefault: name === currentProfile,
+    }));
+  }
+
+  async useProfile(profile: string): Promise<void> {
+    const store = await this.getConfigStore();
+
+    if (!store.profiles[profile]) {
+      throw new Error(`Profile "${profile}" does not exist`);
+    }
+
+    store.defaultProfile = profile;
+    await this.saveConfigStore(store);
+  }
+
+  async getCurrentProfile(): Promise<string> {
+    const store = await this.getConfigStore();
+    return store.defaultProfile || DEFAULT_PROFILE_NAME;
+  }
+
+  async clearConfig(profile?: string): Promise<void> {
+    const store = await this.getConfigStore();
+    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
+
+    delete store.profiles[profileName];
+
+    // If we deleted the default profile, set a new default
+    if (store.defaultProfile === profileName) {
+      const remainingProfiles = Object.keys(store.profiles);
+      if (remainingProfiles.length > 0) {
+        store.defaultProfile = remainingProfiles[0];
+      } else {
+        // No profiles left, delete the config file
+        try {
+          await fs.unlink(this.configPath);
+        } catch (error: unknown) {
+          if (error && typeof error === 'object' && 'code' in error && error.code !== 'ENOENT') {
+            throw error;
+          }
+        }
+        return;
+      }
+    }
+
+    await this.saveConfigStore(store);
+  }
+
+  maskToken(token: string): string {
+    if (token.length <= TOKEN_MIN_LENGTH) {
+      return '****';
+    }
+
+    const prefix = token.substring(0, TOKEN_MASK_LENGTH);
+    const suffix = token.substring(token.length - TOKEN_MASK_LENGTH);
+
+    return `${prefix}-****-****-${suffix}`;
+  }
+
+  private async getConfigStore(): Promise<ConfigStore> {
+    try {
+      const data = await fs.readFile(this.configPath, 'utf-8');
+      const parsed = JSON.parse(data);
+
+      // Handle migration from old format
+      if (this.needsMigration(parsed)) {
+        return await this.migrateOldConfig(parsed);
+      }
+
+      return parsed as ConfigStore;
+    } catch (error: unknown) {
+      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+        return { profiles: {} };
+      }
+      if (error instanceof SyntaxError) {
+        throw new Error(ERROR_MESSAGES.INVALID_CONFIG_FORMAT);
+      }
+      throw error;
+    }
+  }
+
+  private needsMigration(data: any): boolean {
+    return data.token && !data.profiles;
+  }
+
+  private async migrateOldConfig(oldData: any): Promise<ConfigStore> {
+    const oldConfig: Config = {
+      token: oldData.token,
+      updatedAt: oldData.updatedAt,
+    };
+
+    const newStore: ConfigStore = {
+      profiles: { [DEFAULT_PROFILE_NAME]: oldConfig },
+      defaultProfile: DEFAULT_PROFILE_NAME,
+    };
+
+    // Save migrated config
+    await this.saveConfigStore(newStore);
+    return newStore;
+  }
+
+  private async saveConfigStore(store: ConfigStore): Promise<void> {
+    const configDir = path.dirname(this.configPath);
+    await fs.mkdir(configDir, { recursive: true });
+
+    await fs.writeFile(this.configPath, JSON.stringify(store, null, 2));
+    await fs.chmod(this.configPath, FILE_PERMISSIONS.CONFIG_FILE);
+  }
+}
+
+export const profileConfig = {
+  getCurrentProfile: (): string => {
+    return DEFAULT_PROFILE_NAME;
+  },
+  getToken: (_profile?: string): string | undefined => {
+    // This is a simplified version for testing
+    // In real usage, it would need to be async
+    return undefined;
+  },
+};