@plosson/agentio 0.1.5 → 0.1.8

package/src/services/slack/client.ts

@@ -0,0 +1,76 @@
+import { CliError } from '../../utils/errors';
+import type {
+  SlackCredentials,
+  SlackSendOptions,
+  SlackSendResult,
+  SlackWebhookCredentials,
+} from '../../types/slack';
+
+export class SlackClient {
+  private credentials: SlackCredentials;
+
+  constructor(credentials: SlackCredentials) {
+    this.credentials = credentials;
+  }
+
+  async send(options: SlackSendOptions): Promise<SlackSendResult> {
+    if (this.credentials.type === 'webhook') {
+      return this.sendViaWebhook(options);
+    }
+    throw new CliError('INVALID_PARAMS', 'Unknown credentials type');
+  }
+
+  private async sendViaWebhook(options: SlackSendOptions): Promise<SlackSendResult> {
+    const webhookUrl = (this.credentials as SlackWebhookCredentials).webhookUrl;
+
+    if (!webhookUrl?.trim() || !webhookUrl.startsWith('https://')) {
+      throw new CliError(
+        'INVALID_PARAMS',
+        'Invalid webhook URL - must be HTTPS',
+        'Check the webhook URL configuration'
+      );
+    }
+
+    // Use raw payload if provided, otherwise construct simple text message
+    const payload = options.payload ?? { text: options.text };
+
+    try {
+      const response = await fetch(webhookUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new CliError(
+          this.getErrorCode(response.status),
+          `Failed to send message via webhook: ${response.status} ${error}`,
+          'Check that the webhook URL is valid and the app has permission to post'
+        );
+      }
+
+      return {
+        success: true,
+        isJsonPayload: !!options.payload,
+      };
+    } catch (err) {
+      if (err instanceof CliError) throw err;
+      throw new CliError(
+        'NETWORK_ERROR',
+        `Webhook request failed: ${err instanceof Error ? err.message : String(err)}`,
+        'Verify the webhook URL is correct and accessible'
+      );
+    }
+  }
+
+  private getErrorCode(status: number): 'AUTH_FAILED' | 'PERMISSION_DENIED' | 'NOT_FOUND' | 'RATE_LIMITED' | 'API_ERROR' {
+    if (status === 401) return 'AUTH_FAILED';
+    if (status === 403) return 'PERMISSION_DENIED';
+    if (status === 404) return 'NOT_FOUND';
+    if (status === 429) return 'RATE_LIMITED';
+    return 'API_ERROR';
+  }
+}

package/src/types/config.ts

@@ -3,14 +3,16 @@ export interface Config {
     gmail?: string[];
     gchat?: string[];
     jira?: string[];
+    slack?: string[];
     telegram?: string[];
   };
   defaults: {
     gmail?: string;
     gchat?: string;
     jira?: string;
+    slack?: string;
     telegram?: string;
   };
 }
 
-export type ServiceName = 'gmail' | 'gchat' | 'jira' | 'telegram';
+export type ServiceName = 'gmail' | 'gchat' | 'jira' | 'slack' | 'telegram';

package/src/types/jira.ts

@@ -0,0 +1,87 @@
+// JIRA OAuth credentials stored per profile
+// Note: clientId and clientSecret are embedded in the app (see config/credentials.ts)
+export interface JiraCredentials {
+  accessToken: string;
+  refreshToken: string;
+  expiryDate: number;
+  cloudId: string;
+  siteUrl: string;
+}
+
+// JIRA Project
+export interface JiraProject {
+  id: string;
+  key: string;
+  name: string;
+  projectTypeKey: string;
+  simplified: boolean;
+  style: string;
+  isPrivate: boolean;
+  avatarUrls?: Record<string, string>;
+}
+
+// JIRA Issue
+export interface JiraIssue {
+  id: string;
+  key: string;
+  summary: string;
+  status: string;
+  statusCategoryKey: string;
+  priority?: string;
+  assignee?: string;
+  reporter?: string;
+  created: string;
+  updated: string;
+  projectKey: string;
+  issueType: string;
+  description?: string;
+}
+
+// JIRA Issue Transition
+export interface JiraTransition {
+  id: string;
+  name: string;
+  to: {
+    id: string;
+    name: string;
+    statusCategory: {
+      key: string;
+      name: string;
+    };
+  };
+}
+
+// JIRA Comment
+export interface JiraComment {
+  id: string;
+  author: string;
+  body: string;
+  created: string;
+  updated: string;
+}
+
+// Options for search
+export interface JiraSearchOptions {
+  jql?: string;
+  project?: string;
+  status?: string;
+  assignee?: string;
+  maxResults?: number;
+}
+
+// Options for listing projects
+export interface JiraProjectListOptions {
+  maxResults?: number;
+}
+
+// Result types
+export interface JiraCommentResult {
+  id: string;
+  issueKey: string;
+}
+
+export interface JiraTransitionResult {
+  issueKey: string;
+  transitionName: string;
+  newStatus: string;
+}

package/src/types/slack.ts

@@ -0,0 +1,17 @@
+export interface SlackWebhookCredentials {
+  type: 'webhook';
+  webhookUrl: string;
+  channelName?: string; // Optional metadata for display
+}
+
+export type SlackCredentials = SlackWebhookCredentials;
+
+export interface SlackSendOptions {
+  text?: string;
+  payload?: Record<string, unknown>; // Raw JSON payload for Block Kit messages
+}
+
+export interface SlackSendResult {
+  success: boolean;
+  isJsonPayload?: boolean;
+}

package/src/utils/output.ts

@@ -1,5 +1,7 @@
 import type { GmailMessage } from '../types/gmail';
 import type { GChatMessage } from '../types/gchat';
+import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
+import type { SlackSendResult } from '../types/slack';
 
 // Format a list of Gmail messages
 export function printMessageList(messages: GmailMessage[], total: number): void {
@@ -103,3 +105,89 @@ export function printGChatMessage(msg: GChatMessage): void {
     console.log(msg.text);
   }
 }
+
+// JIRA specific formatters
+export function printJiraProjectList(projects: JiraProject[]): void {
+  if (projects.length === 0) {
+    console.log('No projects found');
+    return;
+  }
+
+  console.log(`Projects (${projects.length})\n`);
+
+  for (const project of projects) {
+    const privateMarker = project.isPrivate ? ' [private]' : '';
+    console.log(`${project.key} - ${project.name}${privateMarker}`);
+    console.log(`    Type: ${project.projectTypeKey}`);
+    console.log('');
+  }
+}
+
+export function printJiraIssueList(issues: JiraIssue[]): void {
+  if (issues.length === 0) {
+    console.log('No issues found');
+    return;
+  }
+
+  console.log(`Issues (${issues.length})\n`);
+
+  for (const issue of issues) {
+    console.log(`${issue.key} [${issue.status}] ${issue.summary}`);
+    console.log(`    Type: ${issue.issueType} | Project: ${issue.projectKey}`);
+    if (issue.assignee) console.log(`    Assignee: ${issue.assignee}`);
+    if (issue.priority) console.log(`    Priority: ${issue.priority}`);
+    console.log(`    Updated: ${issue.updated}`);
+    console.log('');
+  }
+}
+
+export function printJiraIssue(issue: JiraIssue): void {
+  console.log(`Key: ${issue.key}`);
+  console.log(`Summary: ${issue.summary}`);
+  console.log(`Status: ${issue.status}`);
+  console.log(`Type: ${issue.issueType}`);
+  console.log(`Project: ${issue.projectKey}`);
+  if (issue.priority) console.log(`Priority: ${issue.priority}`);
+  if (issue.assignee) console.log(`Assignee: ${issue.assignee}`);
+  if (issue.reporter) console.log(`Reporter: ${issue.reporter}`);
+  console.log(`Created: ${issue.created}`);
+  console.log(`Updated: ${issue.updated}`);
+  if (issue.description) {
+    console.log('---');
+    console.log(issue.description);
+  }
+}
+
+export function printJiraTransitions(issueKey: string, transitions: JiraTransition[]): void {
+  if (transitions.length === 0) {
+    console.log(`No transitions available for ${issueKey}`);
+    return;
+  }
+
+  console.log(`Available transitions for ${issueKey}:\n`);
+
+  for (const transition of transitions) {
+    console.log(`[${transition.id}] ${transition.name} → ${transition.to.name}`);
+  }
+}
+
+export function printJiraCommentResult(result: JiraCommentResult): void {
+  console.log('Comment added');
+  console.log(`Issue: ${result.issueKey}`);
+  console.log(`Comment ID: ${result.id}`);
+}
+
+export function printJiraTransitionResult(result: JiraTransitionResult): void {
+  console.log('Issue transitioned');
+  console.log(`Issue: ${result.issueKey}`);
+  console.log(`Transition: ${result.transitionName}`);
+  console.log(`New Status: ${result.newStatus}`);
+}
+
+// Slack specific formatters
+export function printSlackSendResult(result: SlackSendResult): void {
+  console.log('Message sent');
+  if (result.isJsonPayload) {
+    console.log('Type: Block Kit payload');
+  }
+}