agentcord 0.1.0

package/src/setup.ts

@@ -0,0 +1,381 @@
+import * as p from '@clack/prompts';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
+import { execSync } from 'node:child_process';
+
+const ENV_PATH = resolve(process.cwd(), '.env');
+
+function color(text: string, code: number): string {
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+const dim = (t: string) => color(t, 2);
+const cyan = (t: string) => color(t, 36);
+const green = (t: string) => color(t, 32);
+const yellow = (t: string) => color(t, 33);
+const bold = (t: string) => color(t, 1);
+
+function cancelled(): never {
+  p.cancel('Setup cancelled.');
+  process.exit(0);
+}
+
+function loadExistingEnv(): Record<string, string> {
+  if (!existsSync(ENV_PATH)) return {};
+  const env: Record<string, string> = {};
+  for (const line of readFileSync(ENV_PATH, 'utf-8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) continue;
+    env[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+  }
+  return env;
+}
+
+function writeEnvFile(env: Record<string, string>): void {
+  const lines: string[] = [
+    '# agentcord configuration',
+    '# Generated by: npm run setup',
+    '',
+  ];
+
+  const sections: Array<{ comment: string; keys: string[] }> = [
+    { comment: '# Discord App', keys: ['DISCORD_TOKEN', 'DISCORD_CLIENT_ID', 'DISCORD_GUILD_ID'] },
+    { comment: '# Security', keys: ['ALLOWED_USERS', 'ALLOW_ALL_USERS'] },
+    { comment: '# Paths', keys: ['ALLOWED_PATHS', 'DEFAULT_DIRECTORY'] },
+    { comment: '# Optional', keys: ['MESSAGE_RETENTION_DAYS', 'RATE_LIMIT_MS'] },
+  ];
+
+  for (const section of sections) {
+    const sectionEntries = section.keys.filter(k => env[k]);
+    if (sectionEntries.length === 0) continue;
+    lines.push(section.comment);
+    for (const key of sectionEntries) {
+      lines.push(`${key}=${env[key]}`);
+    }
+    lines.push('');
+  }
+
+  writeFileSync(ENV_PATH, lines.join('\n'));
+}
+
+function getDiscordUserId(): string | null {
+  try {
+    // Try to get from existing .env
+    const env = loadExistingEnv();
+    if (env.ALLOWED_USERS) return env.ALLOWED_USERS.split(',')[0].trim();
+  } catch { /* ignore */ }
+  return null;
+}
+
+export async function runSetup(): Promise<void> {
+  const existing = loadExistingEnv();
+  const isReconfigure = Object.keys(existing).length > 0;
+
+  p.intro(bold(' agentcord setup '));
+
+  if (isReconfigure) {
+    p.note(
+      'Existing .env file detected.\nYour current values will be shown as defaults.',
+      'Reconfiguring',
+    );
+  }
+
+  // ─── Step 1: Discord App Creation Guide ───
+
+  const hasApp = await p.confirm({
+    message: 'Do you already have a Discord Application created?',
+    initialValue: !!existing.DISCORD_TOKEN,
+  });
+  if (p.isCancel(hasApp)) cancelled();
+
+  if (!hasApp) {
+    p.note(
+      [
+        `${bold('1.')} Go to ${cyan('https://discord.com/developers/applications')}`,
+        `${bold('2.')} Click ${green('"New Application"')} and give it a name`,
+        `${bold('3.')} Go to the ${bold('Bot')} tab on the left`,
+        `${bold('4.')} Click ${green('"Reset Token"')} and copy the token`,
+        `${bold('5.')} Under ${bold('Privileged Gateway Intents')}, enable:`,
+        `   ${yellow('*')} Message Content Intent`,
+        `   ${yellow('*')} Server Members Intent`,
+        `${bold('6.')} Go to the ${bold('General Information')} tab`,
+        `${bold('7.')} Copy the ${bold('Application ID')} (this is your Client ID)`,
+        '',
+        dim('Keep this tab open — you\'ll need the token and ID next.'),
+      ].join('\n'),
+      'Create a Discord App',
+    );
+
+    await p.confirm({
+      message: 'Ready to continue?',
+      initialValue: true,
+    });
+  }
+
+  // ─── Step 2: Bot Token ───
+
+  const token = await p.password({
+    message: 'Paste your Discord Bot Token:',
+    validate(value) {
+      if (!value || !value.trim()) return 'Token is required';
+      if (value.length < 50) return 'That doesn\'t look like a valid bot token';
+    },
+  });
+  if (p.isCancel(token)) cancelled();
+
+  // ─── Step 3: Client ID ───
+
+  const clientId = await p.text({
+    message: 'Paste your Application (Client) ID:',
+    placeholder: existing.DISCORD_CLIENT_ID || '123456789012345678',
+    initialValue: existing.DISCORD_CLIENT_ID,
+    validate(value) {
+      if (!value || !value.trim()) return 'Client ID is required';
+      if (!/^\d{17,20}$/.test(value.trim())) return 'Client ID should be a 17-20 digit number';
+    },
+  });
+  if (p.isCancel(clientId)) cancelled();
+
+  // ─── Step 4: Guild ID ───
+
+  const guildSetup = await p.confirm({
+    message: 'Do you want to register commands to a specific server? (instant, recommended for testing)',
+    initialValue: !!existing.DISCORD_GUILD_ID,
+  });
+  if (p.isCancel(guildSetup)) cancelled();
+
+  let guildId = '';
+  if (guildSetup) {
+    if (!hasApp) {
+      p.note(
+        [
+          `${bold('1.')} Open Discord and go to ${bold('User Settings > Advanced')}`,
+          `${bold('2.')} Enable ${green('"Developer Mode"')}`,
+          `${bold('3.')} Right-click your server name and click ${green('"Copy Server ID"')}`,
+        ].join('\n'),
+        'How to get your Server ID',
+      );
+    }
+
+    const guildInput = await p.text({
+      message: 'Paste your Server (Guild) ID:',
+      placeholder: existing.DISCORD_GUILD_ID || '123456789012345678',
+      initialValue: existing.DISCORD_GUILD_ID,
+      validate(value) {
+        if (!value || !value.trim()) return 'Guild ID is required';
+        if (!/^\d{17,20}$/.test(value.trim())) return 'Guild ID should be a 17-20 digit number';
+      },
+    });
+    if (p.isCancel(guildInput)) cancelled();
+    guildId = guildInput.trim();
+  }
+
+  // ─── Step 5: Allowed Users ───
+
+  const authMode = await p.select({
+    message: 'Who should be allowed to use the bot?',
+    options: [
+      {
+        value: 'whitelist',
+        label: 'Specific users (recommended)',
+        hint: 'comma-separated Discord user IDs',
+      },
+      {
+        value: 'all',
+        label: 'Everyone in the server',
+        hint: 'not recommended for shared servers',
+      },
+    ],
+    initialValue: existing.ALLOW_ALL_USERS === 'true' ? 'all' : 'whitelist',
+  });
+  if (p.isCancel(authMode)) cancelled();
+
+  let allowedUsers = '';
+  if (authMode === 'whitelist') {
+    const existingUser = getDiscordUserId();
+
+    if (!hasApp && !existingUser) {
+      p.note(
+        [
+          `${bold('1.')} Open Discord with ${bold('Developer Mode')} enabled`,
+          `${bold('2.')} Click on your profile picture or username`,
+          `${bold('3.')} Click ${green('"Copy User ID"')}`,
+          '',
+          dim('You can add more users later by editing .env'),
+        ].join('\n'),
+        'How to get your User ID',
+      );
+    }
+
+    const usersInput = await p.text({
+      message: 'Enter allowed Discord User IDs (comma-separated):',
+      placeholder: '123456789012345678',
+      initialValue: existing.ALLOWED_USERS,
+      validate(value) {
+        if (!value || !value.trim()) return 'At least one user ID is required';
+        const ids = value.split(',').map(s => s.trim());
+        for (const id of ids) {
+          if (!/^\d{17,20}$/.test(id)) return `Invalid user ID: ${id}`;
+        }
+      },
+    });
+    if (p.isCancel(usersInput)) cancelled();
+    allowedUsers = usersInput.trim();
+  }
+
+  // ─── Step 6: Paths ───
+
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '/';
+
+  const defaultDir = await p.text({
+    message: 'Default working directory for new sessions:',
+    placeholder: homeDir,
+    initialValue: existing.DEFAULT_DIRECTORY || homeDir,
+    validate(value) {
+      if (!value) return 'Directory is required';
+      const resolved = resolve(value.trim().replace(/^~/, homeDir));
+      if (!existsSync(resolved)) return `Directory does not exist: ${resolved}`;
+    },
+  });
+  if (p.isCancel(defaultDir)) cancelled();
+  const resolvedDefault = resolve(defaultDir.trim().replace(/^~/, homeDir));
+
+  const restrictPaths = await p.confirm({
+    message: 'Restrict which directories the bot can access?',
+    initialValue: !!existing.ALLOWED_PATHS,
+  });
+  if (p.isCancel(restrictPaths)) cancelled();
+
+  let allowedPaths = '';
+  if (restrictPaths) {
+    const pathsInput = await p.text({
+      message: 'Allowed directories (comma-separated):',
+      placeholder: `${homeDir}/Dev,${homeDir}/Projects`,
+      initialValue: existing.ALLOWED_PATHS || resolvedDefault,
+      validate(value) {
+        if (!value || !value.trim()) return 'At least one path is required';
+      },
+    });
+    if (p.isCancel(pathsInput)) cancelled();
+    allowedPaths = pathsInput.trim();
+  }
+
+  // ─── Step 7: Write .env ───
+
+  const env: Record<string, string> = {
+    DISCORD_TOKEN: token.trim(),
+    DISCORD_CLIENT_ID: clientId.trim(),
+  };
+  if (guildId) env.DISCORD_GUILD_ID = guildId;
+  if (authMode === 'all') {
+    env.ALLOW_ALL_USERS = 'true';
+  } else {
+    env.ALLOWED_USERS = allowedUsers;
+  }
+  env.DEFAULT_DIRECTORY = resolvedDefault;
+  if (allowedPaths) env.ALLOWED_PATHS = allowedPaths;
+
+  // Preserve optional settings from existing config
+  if (existing.MESSAGE_RETENTION_DAYS) env.MESSAGE_RETENTION_DAYS = existing.MESSAGE_RETENTION_DAYS;
+  if (existing.RATE_LIMIT_MS) env.RATE_LIMIT_MS = existing.RATE_LIMIT_MS;
+
+  const s = p.spinner();
+  s.start('Writing .env file');
+  writeEnvFile(env);
+  s.stop('Configuration saved to .env');
+
+  // ─── Step 8: Generate Invite URL ───
+
+  const permissions = 8; // Administrator (simplest for category/channel management)
+  const scopes = 'bot%20applications.commands';
+  const inviteUrl = `https://discord.com/oauth2/authorize?client_id=${clientId.trim()}&permissions=${permissions}&scope=${scopes}`;
+
+  p.note(
+    [
+      bold('Add the bot to your server:'),
+      '',
+      cyan(inviteUrl),
+      '',
+      dim('Open this URL in your browser and select your server.'),
+    ].join('\n'),
+    'Invite Link',
+  );
+
+  const openBrowser = await p.confirm({
+    message: 'Open the invite URL in your browser?',
+    initialValue: true,
+  });
+  if (p.isCancel(openBrowser)) cancelled();
+
+  if (openBrowser) {
+    try {
+      const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+      execSync(`${cmd} "${inviteUrl}"`, { stdio: 'ignore' });
+    } catch {
+      p.log.warn('Could not open browser. Please open the URL manually.');
+    }
+  }
+
+  // ─── Step 9: Verify Connection ───
+
+  const verify = await p.confirm({
+    message: 'Test the bot connection now?',
+    initialValue: true,
+  });
+  if (p.isCancel(verify)) cancelled();
+
+  if (verify) {
+    s.start('Connecting to Discord...');
+    try {
+      // Dynamic import to avoid loading discord.js at module level
+      const { Client, GatewayIntentBits } = await import('discord.js');
+      const client = new Client({
+        intents: [GatewayIntentBits.Guilds],
+      });
+
+      const loginResult = await Promise.race([
+        new Promise<string>((res, rej) => {
+          client.once('ready', () => {
+            const name = client.user?.tag || 'Unknown';
+            const guildCount = client.guilds.cache.size;
+            client.destroy();
+            res(`${name} — connected to ${guildCount} server(s)`);
+          });
+          client.login(token.trim()).catch(rej);
+        }),
+        new Promise<never>((_, rej) =>
+          setTimeout(() => rej(new Error('Connection timed out after 15s')), 15000),
+        ),
+      ]);
+
+      s.stop(green(`Connected: ${loginResult}`));
+    } catch (err: unknown) {
+      s.stop(`Connection failed: ${(err as Error).message}`);
+      p.log.warn('Double-check your bot token and try again.');
+      p.log.info(`You can re-run setup with: ${cyan('npm run setup')}`);
+    }
+  }
+
+  // ─── Done ───
+
+  p.note(
+    [
+      `Start the bot:  ${cyan('npm start')}`,
+      `Dev mode:       ${cyan('npm run dev')}`,
+      `Re-run setup:   ${cyan('npm run setup')}`,
+      '',
+      `Once running, use ${bold('/claude new <name> <directory>')} in Discord`,
+      `to create your first session.`,
+    ].join('\n'),
+    'Next Steps',
+  );
+
+  p.outro(green('Setup complete!'));
+}
+
+// Run if called directly
+runSetup().catch(err => {
+  console.error('Setup failed:', err);
+  process.exit(1);
+});

package/src/shell-handler.ts

@@ -0,0 +1,91 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import type { TextChannel } from 'discord.js';
+import type { ShellProcess } from './types.ts';
+import { truncate } from './utils.ts';
+
+const runningProcesses = new Map<number, ShellProcess>();
+let pidCounter = 0;
+
+const TIMEOUT_MS = 60_000;
+const EDIT_DEBOUNCE = 500;
+
+export async function executeShellCommand(
+  command: string,
+  cwd: string,
+  channel: TextChannel,
+): Promise<void> {
+  const pid = ++pidCounter;
+  const child = spawn('bash', ['-c', command], {
+    cwd,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  const shellProcess: ShellProcess = {
+    pid,
+    command,
+    startedAt: Date.now(),
+    process: child,
+  };
+  runningProcesses.set(pid, shellProcess);
+
+  let output = '';
+  let message = await channel.send(`\`\`\`\n$ ${command}\n\`\`\``);
+  let lastEdit = Date.now();
+  let editTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const updateMessage = async () => {
+    const display = truncate(output, 1900);
+    try {
+      await message.edit(`\`\`\`\n$ ${command}\n${display}\n\`\`\``);
+    } catch { /* message deleted */ }
+    lastEdit = Date.now();
+  };
+
+  const scheduleEdit = () => {
+    if (editTimer) return;
+    const delay = Math.max(0, EDIT_DEBOUNCE - (Date.now() - lastEdit));
+    editTimer = setTimeout(async () => {
+      editTimer = null;
+      await updateMessage();
+    }, delay);
+  };
+
+  const onData = (chunk: Buffer) => {
+    output += chunk.toString();
+    scheduleEdit();
+  };
+
+  child.stdout?.on('data', onData);
+  child.stderr?.on('data', onData);
+
+  // Timeout
+  const timeout = setTimeout(() => {
+    child.kill('SIGTERM');
+    output += '\n[Timed out after 60s]';
+  }, TIMEOUT_MS);
+
+  return new Promise<void>(resolve => {
+    child.on('close', async (code) => {
+      clearTimeout(timeout);
+      if (editTimer) clearTimeout(editTimer);
+      runningProcesses.delete(pid);
+
+      output += `\n[Exit code: ${code ?? 'killed'}]`;
+      await updateMessage();
+      resolve();
+    });
+  });
+}
+
+export function listProcesses(): ShellProcess[] {
+  return Array.from(runningProcesses.values());
+}
+
+export function killProcess(pid: number): boolean {
+  const proc = runningProcesses.get(pid);
+  if (!proc) return false;
+  proc.process.kill('SIGTERM');
+  runningProcesses.delete(pid);
+  return true;
+}

package/src/types.ts

@@ -0,0 +1,80 @@
+export interface McpServer {
+  name: string;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface Project {
+  name: string;
+  directory: string;
+  categoryId: string;
+  logChannelId?: string;
+  personality?: string;
+  skills: Record<string, string>;
+  mcpServers: McpServer[];
+}
+
+export interface Session {
+  id: string;
+  channelId: string;
+  directory: string;
+  projectName: string;
+  tmuxName: string;
+  claudeSessionId?: string;
+  model?: string;
+  agentPersona?: string;
+  verbose: boolean;
+  isGenerating: boolean;
+  createdAt: number;
+  lastActivity: number;
+  messageCount: number;
+  totalCost: number;
+}
+
+export interface SessionPersistData {
+  id: string;
+  channelId: string;
+  directory: string;
+  projectName: string;
+  tmuxName: string;
+  claudeSessionId?: string;
+  model?: string;
+  agentPersona?: string;
+  verbose?: boolean;
+  createdAt: number;
+  lastActivity: number;
+  messageCount: number;
+  totalCost: number;
+}
+
+export interface AgentPersona {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  emoji: string;
+}
+
+export interface ShellProcess {
+  pid: number;
+  command: string;
+  startedAt: number;
+  process: import('node:child_process').ChildProcess;
+}
+
+export interface Config {
+  token: string;
+  clientId: string;
+  guildId: string | null;
+  allowedUsers: string[];
+  allowAllUsers: boolean;
+  allowedPaths: string[];
+  defaultDirectory: string;
+  messageRetentionDays: number | null;
+  rateLimitMs: number;
+}
+
+export interface ExpandableContent {
+  content: string;
+  createdAt: number;
+}

package/src/utils.ts

@@ -0,0 +1,112 @@
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+export function sanitizeSessionName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 50);
+}
+
+export function formatUptime(startTime: number): string {
+  const ms = Date.now() - startTime;
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+
+export function formatLastActivity(timestamp: number): string {
+  const ms = Date.now() - timestamp;
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return 'just now';
+}
+
+export function isPathAllowed(targetPath: string, allowedPaths: string[]): boolean {
+  if (allowedPaths.length === 0) return true;
+  const resolved = resolve(targetPath);
+  return allowedPaths.some(allowed => {
+    const resolvedAllowed = resolve(allowed.startsWith('~') ? allowed.replace('~', homedir()) : allowed);
+    return resolved === resolvedAllowed || resolved.startsWith(resolvedAllowed + '/');
+  });
+}
+
+export function resolvePath(dir: string): string {
+  const expanded = dir.startsWith('~') ? dir.replace('~', homedir()) : dir;
+  return resolve(expanded);
+}
+
+export function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + '...';
+}
+
+export function splitMessage(text: string, maxLen: number = 1900): string[] {
+  if (text.length <= maxLen) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+
+    let splitAt = remaining.lastIndexOf('\n', maxLen);
+    if (splitAt === -1 || splitAt < maxLen / 2) {
+      splitAt = maxLen;
+    }
+
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n/, '');
+  }
+
+  return chunks;
+}
+
+export function isUserAllowed(userId: string, allowedUsers: string[], allowAll: boolean): boolean {
+  if (allowAll) return true;
+  return allowedUsers.includes(userId);
+}
+
+export function projectNameFromDir(directory: string): string {
+  const resolved = resolvePath(directory);
+  const basename = resolved.split('/').pop() || 'unknown';
+  return sanitizeSessionName(basename);
+}
+
+export function detectNumberedOptions(text: string): string[] | null {
+  const lines = text.trim().split('\n');
+  const options: string[] = [];
+  const optionRegex = /^\s*(\d+)[.)]\s+(.+)$/;
+
+  for (const line of lines) {
+    const match = line.match(optionRegex);
+    if (match) {
+      options.push(match[2].trim());
+    }
+  }
+
+  return options.length >= 2 ? options : null;
+}
+
+export function detectYesNoPrompt(text: string): boolean {
+  const lower = text.toLowerCase();
+  return /\b(y\/n|yes\/no|confirm|proceed)\b/.test(lower) ||
+    /\?\s*$/.test(text.trim()) && /\b(should|would you|do you want|shall)\b/.test(lower);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}