@plosson/agentio 0.1.5 → 0.1.8

package/src/commands/slack.ts

@@ -0,0 +1,265 @@
+import { Command } from 'commander';
+import { createInterface } from 'readline';
+import { readFile } from 'fs/promises';
+import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
+import { setProfile, removeProfile, listProfiles, getProfile } from '../config/config-manager';
+import { SlackClient } from '../services/slack/client';
+import { CliError, handleError } from '../utils/errors';
+import { readStdin } from '../utils/stdin';
+import { printSlackSendResult } from '../utils/output';
+import type { SlackCredentials, SlackWebhookCredentials } from '../types/slack';
+
+function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function getSlackClient(profileName?: string): Promise<{ client: SlackClient; profile: string }> {
+  const profile = await getProfile('slack', profileName);
+
+  if (!profile) {
+    throw new CliError(
+      'PROFILE_NOT_FOUND',
+      profileName
+        ? `Profile "${profileName}" not found for slack`
+        : 'No default profile configured for slack',
+      'Run: agentio slack profile add'
+    );
+  }
+
+  const credentials = await getCredentials<SlackCredentials>('slack', profile);
+
+  if (!credentials) {
+    throw new CliError(
+      'AUTH_FAILED',
+      `No credentials found for slack profile "${profile}"`,
+      `Run: agentio slack profile add --profile ${profile}`
+    );
+  }
+
+  return {
+    client: new SlackClient(credentials),
+    profile,
+  };
+}
+
+export function registerSlackCommands(program: Command): void {
+  const slack = program
+    .command('slack')
+    .description('Slack operations');
+
+  slack
+    .command('send')
+    .description('Send a message to Slack')
+    .option('--profile <name>', 'Profile name')
+    .option('--json [file]', 'Send Block Kit message from JSON file (or stdin if no file specified)')
+    .argument('[message]', 'Message text (or pipe via stdin)')
+    .action(async (message: string | undefined, options) => {
+      try {
+        let text: string | undefined = message;
+        let payload: Record<string, unknown> | undefined;
+
+        // Handle --json option
+        if (options.json !== undefined) {
+          // Check mutual exclusivity
+          if (message) {
+            throw new CliError(
+              'INVALID_PARAMS',
+              'Cannot use both text message and --json option',
+              'Use either: agentio slack send "text" OR agentio slack send --json file.json'
+            );
+          }
+
+          let jsonContent: string;
+
+          if (typeof options.json === 'string') {
+            // Read from file
+            try {
+              jsonContent = await readFile(options.json, 'utf-8');
+            } catch (err) {
+              throw new CliError(
+                'INVALID_PARAMS',
+                `Failed to read JSON file: ${options.json}`,
+                'Check that the file exists and is readable'
+              );
+            }
+          } else {
+            // Read from stdin
+            const stdinContent = await readStdin();
+            if (!stdinContent) {
+              throw new CliError(
+                'INVALID_PARAMS',
+                'No JSON provided via stdin',
+                'Pipe JSON content: cat message.json | agentio slack send --json'
+              );
+            }
+            jsonContent = stdinContent;
+          }
+
+          // Parse JSON
+          try {
+            payload = JSON.parse(jsonContent) as Record<string, unknown>;
+          } catch (err) {
+            throw new CliError(
+              'INVALID_PARAMS',
+              `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+              'Check that the JSON is valid'
+            );
+          }
+        } else {
+          // Text message mode
+          if (!text) {
+            text = await readStdin() || undefined;
+          }
+
+          if (!text) {
+            throw new CliError('INVALID_PARAMS', 'Message is required. Provide as argument or pipe via stdin.');
+          }
+        }
+
+        const { client } = await getSlackClient(options.profile);
+        const result = await client.send({
+          text,
+          payload,
+        });
+
+        printSlackSendResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = slack
+    .command('profile')
+    .description('Manage Slack profiles');
+
+  profile
+    .command('add')
+    .description('Add a new Slack profile (webhook)')
+    .option('--profile <name>', 'Profile name', 'default')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+        await setupWebhookProfile(profileName);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('list')
+    .description('List Slack profiles')
+    .action(async () => {
+      try {
+        const result = await listProfiles('slack');
+        const { profiles, default: defaultProfile } = result[0];
+
+        if (profiles.length === 0) {
+          console.log('No profiles configured');
+        } else {
+          for (const name of profiles) {
+            const marker = name === defaultProfile ? ' (default)' : '';
+            const credentials = await getCredentials<SlackCredentials>('slack', name);
+            const channelInfo = credentials?.channelName ? ` - #${credentials.channelName}` : ' - webhook';
+            console.log(`${name}${marker}${channelInfo}`);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('remove')
+    .description('Remove a Slack profile')
+    .requiredOption('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        const removed = await removeProfile('slack', profileName);
+        await removeCredentials('slack', profileName);
+
+        if (removed) {
+          console.log(`Removed profile "${profileName}"`);
+        } else {
+          console.error(`Profile "${profileName}" not found`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}
+
+async function setupWebhookProfile(profileName: string): Promise<void> {
+  console.error('\nSlack Webhook Setup\n');
+  console.error('1. Go to https://api.slack.com/apps and create a new app (or use existing)');
+  console.error('2. Enable "Incoming Webhooks" in Features');
+  console.error('3. Click "Add New Webhook to Workspace" and select a channel');
+  console.error('4. Copy the Webhook URL\n');
+
+  const webhookUrl = await prompt('? Paste your webhook URL: ');
+
+  if (!webhookUrl) {
+    throw new CliError('INVALID_PARAMS', 'Webhook URL is required');
+  }
+
+  if (!webhookUrl.startsWith('https://hooks.slack.com/')) {
+    throw new CliError(
+      'INVALID_PARAMS',
+      'Invalid Slack webhook URL',
+      'URL should start with https://hooks.slack.com/'
+    );
+  }
+
+  // Validate webhook with a test request
+  try {
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ text: 'Test message from agentio setup' }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new CliError(
+        'API_ERROR',
+        `Webhook validation failed: ${response.status} ${error}`,
+        'Check the webhook URL and try again'
+      );
+    }
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    throw new CliError(
+      'API_ERROR',
+      `Failed to validate webhook: ${err instanceof Error ? err.message : String(err)}`,
+      'Check that the URL is correct and accessible'
+    );
+  }
+
+  const channelName = await prompt('? Channel name (optional, for display): ');
+
+  const credentials: SlackWebhookCredentials = {
+    type: 'webhook',
+    webhookUrl: webhookUrl,
+    channelName: channelName || undefined,
+  };
+
+  await setProfile('slack', profileName);
+  await setCredentials('slack', profileName, credentials);
+
+  console.log(`\nSuccess! Webhook profile "${profileName}" configured.`);
+  console.log(`   Test with: agentio slack send --profile ${profileName} "Hello from agentio"`);
+}

package/src/config/credentials.ts

@@ -11,3 +11,12 @@ export const GOOGLE_OAUTH_CONFIG = {
   clientId: CLIENT_ID,
   clientSecret: reveal(CLIENT_SECRET_ENC),
 };
+
+// JIRA/Atlassian OAuth credentials
+const JIRA_CLIENT_ID = '7408S0MZKdYnsiz0KXlUT15Lb69k7y0e';
+const JIRA_CLIENT_SECRET_ENC = 'C0J5Cyvhfl_UHCvmY9BfvKa_gzqdaa5mb3FwzRmq-YApJdAoBAKmeCl3xmcYLRCFdMvQLWVmifTkryoB0bmhVWX6eRTzoj1q4iyyTxZzT0yff0pYvLguHzp9Y4U';
+
+export const JIRA_OAUTH_CONFIG = {
+  clientId: JIRA_CLIENT_ID,
+  clientSecret: reveal(JIRA_CLIENT_SECRET_ENC),
+};

package/src/index.ts

@@ -3,6 +3,8 @@ import { Command } from 'commander';
 import { registerGmailCommands } from './commands/gmail';
 import { registerTelegramCommands } from './commands/telegram';
 import { registerGChatCommands } from './commands/gchat';
+import { registerJiraCommands } from './commands/jira';
+import { registerSlackCommands } from './commands/slack';
 
 const program = new Command();
 
@@ -14,5 +16,7 @@ program
 registerGmailCommands(program);
 registerTelegramCommands(program);
 registerGChatCommands(program);
+registerJiraCommands(program);
+registerSlackCommands(program);
 
 program.parse();

package/src/services/jira/client.ts

@@ -0,0 +1,355 @@
+import { CliError, type ErrorCode } from '../../utils/errors';
+import type {
+  JiraCredentials,
+  JiraProject,
+  JiraIssue,
+  JiraTransition,
+  JiraComment,
+  JiraSearchOptions,
+  JiraProjectListOptions,
+  JiraCommentResult,
+  JiraTransitionResult,
+} from '../../types/jira';
+
+export class JiraClient {
+  private credentials: JiraCredentials;
+  private baseUrl: string;
+
+  constructor(credentials: JiraCredentials) {
+    this.credentials = credentials;
+    this.baseUrl = `https://api.atlassian.com/ex/jira/${credentials.cloudId}/rest/api/3`;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.credentials.accessToken}`,
+      Accept: 'application/json',
+    };
+
+    if (body) {
+      headers['Content-Type'] = 'application/json';
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      const code = this.getErrorCode(response.status);
+      throw new CliError(code, `JIRA API error: ${errorText}`);
+    }
+
+    // Some endpoints return 204 No Content
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    return response.json();
+  }
+
+  private getErrorCode(status: number): ErrorCode {
+    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';
+  }
+
+  async listProjects(options: JiraProjectListOptions = {}): Promise<JiraProject[]> {
+    const params = new URLSearchParams();
+    if (options.maxResults) {
+      params.set('maxResults', String(options.maxResults));
+    }
+
+    const queryString = params.toString();
+    const path = `/project/search${queryString ? `?${queryString}` : ''}`;
+
+    interface ProjectSearchResponse {
+      values: Array<{
+        id: string;
+        key: string;
+        name: string;
+        projectTypeKey: string;
+        simplified: boolean;
+        style: string;
+        isPrivate: boolean;
+        avatarUrls?: Record<string, string>;
+      }>;
+    }
+
+    const response = await this.request<ProjectSearchResponse>('GET', path);
+
+    return response.values.map((p) => ({
+      id: p.id,
+      key: p.key,
+      name: p.name,
+      projectTypeKey: p.projectTypeKey,
+      simplified: p.simplified,
+      style: p.style,
+      isPrivate: p.isPrivate,
+      avatarUrls: p.avatarUrls,
+    }));
+  }
+
+  async searchIssues(options: JiraSearchOptions = {}): Promise<JiraIssue[]> {
+    // Build JQL query
+    const jqlParts: string[] = [];
+
+    if (options.jql) {
+      jqlParts.push(options.jql);
+    }
+    if (options.project) {
+      jqlParts.push(`project = "${options.project}"`);
+    }
+    if (options.status) {
+      jqlParts.push(`status = "${options.status}"`);
+    }
+    if (options.assignee) {
+      jqlParts.push(`assignee = "${options.assignee}"`);
+    }
+
+    const jql = jqlParts.join(' AND ') || 'ORDER BY created DESC';
+    const maxResults = options.maxResults || 50;
+
+    const params = new URLSearchParams();
+    params.set('jql', jql);
+    params.set('maxResults', String(maxResults));
+    params.set('fields', 'summary,status,priority,assignee,reporter,created,updated,project,issuetype,description');
+
+    interface SearchResponse {
+      issues: Array<{
+        id: string;
+        key: string;
+        fields: {
+          summary: string;
+          status: {
+            name: string;
+            statusCategory: { key: string };
+          };
+          priority?: { name: string };
+          assignee?: { displayName: string };
+          reporter?: { displayName: string };
+          created: string;
+          updated: string;
+          project: { key: string };
+          issuetype: { name: string };
+          description?: unknown;
+        };
+      }>;
+    }
+
+    const response = await this.request<SearchResponse>('GET', `/search/jql?${params.toString()}`);
+
+    return response.issues.map((issue) => ({
+      id: issue.id,
+      key: issue.key,
+      summary: issue.fields.summary,
+      status: issue.fields.status.name,
+      statusCategoryKey: issue.fields.status.statusCategory.key,
+      priority: issue.fields.priority?.name,
+      assignee: issue.fields.assignee?.displayName,
+      reporter: issue.fields.reporter?.displayName,
+      created: issue.fields.created,
+      updated: issue.fields.updated,
+      projectKey: issue.fields.project.key,
+      issueType: issue.fields.issuetype.name,
+      description: this.extractTextFromAdf(issue.fields.description),
+    }));
+  }
+
+  async getIssue(issueKey: string): Promise<JiraIssue> {
+    interface IssueResponse {
+      id: string;
+      key: string;
+      fields: {
+        summary: string;
+        status: {
+          name: string;
+          statusCategory: { key: string };
+        };
+        priority?: { name: string };
+        assignee?: { displayName: string };
+        reporter?: { displayName: string };
+        created: string;
+        updated: string;
+        project: { key: string };
+        issuetype: { name: string };
+        description?: unknown;
+      };
+    }
+
+    const response = await this.request<IssueResponse>('GET', `/issue/${issueKey}`);
+
+    return {
+      id: response.id,
+      key: response.key,
+      summary: response.fields.summary,
+      status: response.fields.status.name,
+      statusCategoryKey: response.fields.status.statusCategory.key,
+      priority: response.fields.priority?.name,
+      assignee: response.fields.assignee?.displayName,
+      reporter: response.fields.reporter?.displayName,
+      created: response.fields.created,
+      updated: response.fields.updated,
+      projectKey: response.fields.project.key,
+      issueType: response.fields.issuetype.name,
+      description: this.extractTextFromAdf(response.fields.description),
+    };
+  }
+
+  async getTransitions(issueKey: string): Promise<JiraTransition[]> {
+    interface TransitionsResponse {
+      transitions: Array<{
+        id: string;
+        name: string;
+        to: {
+          id: string;
+          name: string;
+          statusCategory: {
+            key: string;
+            name: string;
+          };
+        };
+      }>;
+    }
+
+    const response = await this.request<TransitionsResponse>('GET', `/issue/${issueKey}/transitions`);
+
+    return response.transitions.map((t) => ({
+      id: t.id,
+      name: t.name,
+      to: {
+        id: t.to.id,
+        name: t.to.name,
+        statusCategory: {
+          key: t.to.statusCategory.key,
+          name: t.to.statusCategory.name,
+        },
+      },
+    }));
+  }
+
+  async transitionIssue(issueKey: string, transitionId: string): Promise<JiraTransitionResult> {
+    // Get transitions first to find the name
+    const transitions = await this.getTransitions(issueKey);
+    const transition = transitions.find((t) => t.id === transitionId);
+
+    if (!transition) {
+      throw new CliError('NOT_FOUND', `Transition "${transitionId}" not found or not available for this issue`);
+    }
+
+    await this.request<void>('POST', `/issue/${issueKey}/transitions`, {
+      transition: { id: transitionId },
+    });
+
+    return {
+      issueKey,
+      transitionName: transition.name,
+      newStatus: transition.to.name,
+    };
+  }
+
+  async addComment(issueKey: string, body: string): Promise<JiraCommentResult> {
+    // JIRA v3 API requires Atlassian Document Format (ADF)
+    const adfBody = this.textToAdf(body);
+
+    interface CommentResponse {
+      id: string;
+    }
+
+    const response = await this.request<CommentResponse>('POST', `/issue/${issueKey}/comment`, {
+      body: adfBody,
+    });
+
+    return {
+      id: response.id,
+      issueKey,
+    };
+  }
+
+  async getComments(issueKey: string): Promise<JiraComment[]> {
+    interface CommentsResponse {
+      comments: Array<{
+        id: string;
+        author: { displayName: string };
+        body: unknown;
+        created: string;
+        updated: string;
+      }>;
+    }
+
+    const response = await this.request<CommentsResponse>('GET', `/issue/${issueKey}/comment`);
+
+    return response.comments.map((c) => ({
+      id: c.id,
+      author: c.author.displayName,
+      body: this.extractTextFromAdf(c.body),
+      created: c.created,
+      updated: c.updated,
+    }));
+  }
+
+  // Convert plain text to Atlassian Document Format (ADF)
+  private textToAdf(text: string): object {
+    const paragraphs = text.split('\n\n');
+
+    return {
+      version: 1,
+      type: 'doc',
+      content: paragraphs.map((paragraph) => ({
+        type: 'paragraph',
+        content: paragraph.split('\n').flatMap((line, index, array) => {
+          const parts: object[] = [{ type: 'text', text: line }];
+          if (index < array.length - 1) {
+            parts.push({ type: 'hardBreak' });
+          }
+          return parts;
+        }),
+      })),
+    };
+  }
+
+  // Extract plain text from Atlassian Document Format (ADF)
+  private extractTextFromAdf(adf: unknown): string {
+    if (!adf || typeof adf !== 'object') {
+      return '';
+    }
+
+    const doc = adf as { content?: Array<{ type: string; content?: Array<{ text?: string; type?: string }> }> };
+    if (!doc.content) {
+      return '';
+    }
+
+    const extractText = (node: unknown): string => {
+      if (!node || typeof node !== 'object') return '';
+
+      const n = node as { type?: string; text?: string; content?: unknown[] };
+
+      if (n.type === 'text' && n.text) {
+        return n.text;
+      }
+
+      if (n.type === 'hardBreak') {
+        return '\n';
+      }
+
+      if (Array.isArray(n.content)) {
+        return n.content.map(extractText).join('');
+      }
+
+      return '';
+    };
+
+    return doc.content
+      .map((block) => extractText(block))
+      .join('\n\n');
+  }
+}