typeclaw 0.1.0

package/src/cli/channel.ts

@@ -0,0 +1,403 @@
+import { cancel, confirm, intro, isCancel, log, note, password, select, spinner, text } from '@clack/prompts'
+import { defineCommand } from 'citty'
+
+import { config } from '@/config'
+import { start, status, stop } from '@/container'
+import {
+  CHANNEL_KINDS,
+  findAgentDir,
+  isInitialized,
+  readConfiguredChannels,
+  runAddChannel,
+  type AddChannelStepEvent,
+  type ChannelKind,
+  type KakaotalkAuthResult,
+} from '@/init'
+import { runKakaotalkBootstrap } from '@/init/kakaotalk-auth'
+
+import { c, done, errorLine } from './ui'
+
+const CHANNEL_LABELS: Record<ChannelKind, string> = {
+  'slack-bot': 'Slack',
+  'discord-bot': 'Discord',
+  'telegram-bot': 'Telegram',
+  kakaotalk: 'KakaoTalk',
+}
+
+const addSub = defineCommand({
+  meta: {
+    name: 'add',
+    description: 'add a new channel adapter to an existing agent (run this from inside the agent folder)',
+  },
+  args: {
+    adapter: {
+      type: 'positional',
+      description: `which adapter to add (${CHANNEL_KINDS.join(' | ')}); omit to pick interactively`,
+      required: false,
+    },
+  },
+  async run({ args }) {
+    const cwd = findAgentDir(process.cwd()) ?? process.cwd()
+
+    if (!isInitialized(cwd)) {
+      console.error(errorLine('TypeClaw config file not found. Run `typeclaw init` first, or cd into an agent folder.'))
+      process.exit(1)
+    }
+
+    const configured = await readConfiguredChannels(cwd)
+    const requested = args.adapter
+    const channel = requested === undefined ? await pickChannel(configured) : validateAdapterArg(requested, configured)
+
+    intro(`Adding channel: ${CHANNEL_LABELS[channel]}`)
+
+    const credentials = await collectCredentials(channel)
+
+    const events: AddChannelStepEvent[] = []
+    try {
+      await runAddChannel({
+        cwd,
+        ...credentials,
+        onProgress: reportProgress(events),
+      })
+    } catch (error) {
+      console.error(errorLine(error instanceof Error ? error.message : String(error)))
+      process.exit(1)
+    }
+
+    await maybePromptRestart(cwd, channel)
+  },
+})
+
+export const channelCommand = defineCommand({
+  meta: {
+    name: 'channel',
+    description: 'manage channel adapters wired into the agent',
+  },
+  subCommands: {
+    add: addSub,
+  },
+})
+
+function validateAdapterArg(adapter: string, configured: Set<ChannelKind>): ChannelKind {
+  if (!isChannelKind(adapter)) {
+    console.error(errorLine(`Unknown adapter "${adapter}". Expected one of: ${CHANNEL_KINDS.join(', ')}.`))
+    process.exit(1)
+  }
+  if (configured.has(adapter)) {
+    console.error(
+      errorLine(
+        `${CHANNEL_LABELS[adapter]} ("${adapter}") is already configured in typeclaw.json. Edit the file directly to change its allow list.`,
+      ),
+    )
+    process.exit(1)
+  }
+  return adapter
+}
+
+function isChannelKind(value: string): value is ChannelKind {
+  return (CHANNEL_KINDS as ReadonlyArray<string>).includes(value)
+}
+
+async function pickChannel(configured: Set<ChannelKind>): Promise<ChannelKind> {
+  const available = CHANNEL_KINDS.filter((kind) => !configured.has(kind))
+  if (available.length === 0) {
+    console.error(errorLine('All supported channel adapters are already configured in typeclaw.json. Nothing to add.'))
+    process.exit(0)
+  }
+
+  const selected = await select<ChannelKind>({
+    message: 'Pick a channel to add',
+    options: available.map((kind) => ({ value: kind, label: CHANNEL_LABELS[kind] })),
+    initialValue: available[0],
+  })
+  if (isCancel(selected)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  return selected
+}
+
+type CollectedCredentials =
+  | { channel: 'discord-bot'; discordBotToken: string }
+  | { channel: 'slack-bot'; slackBotToken: string; slackAppToken: string }
+  | { channel: 'telegram-bot'; telegramBotToken: string }
+  | { channel: 'kakaotalk'; runKakaotalkAuth: (options: { cwd: string }) => Promise<KakaotalkAuthResult> }
+
+async function collectCredentials(channel: ChannelKind): Promise<CollectedCredentials> {
+  switch (channel) {
+    case 'discord-bot':
+      return { channel, discordBotToken: await promptDiscordToken() }
+    case 'slack-bot': {
+      const slack = await promptSlackTokens()
+      return { channel, slackBotToken: slack.bot, slackAppToken: slack.app }
+    }
+    case 'telegram-bot':
+      return { channel, telegramBotToken: await promptTelegramToken() }
+    case 'kakaotalk': {
+      const creds = await promptKakaotalkCredentials()
+      return {
+        channel,
+        runKakaotalkAuth: ({ cwd: agentDir }) =>
+          runKakaotalkBootstrap({
+            email: creds.email,
+            password: creds.password,
+            agentDir,
+            callbacks: { onPasscode: (code) => log.info(`Confirm this passcode on your phone: ${code}`) },
+          }),
+      }
+    }
+  }
+}
+
+async function promptDiscordToken(): Promise<string> {
+  note(
+    [
+      'https://discord.com/developers/applications',
+      'New Application → Bot tab → Reset Token.',
+      'Enable the MESSAGE CONTENT intent.',
+    ].join('\n'),
+    'Get a Discord bot token',
+  )
+  const token = await password({
+    message: 'Discord bot token',
+    validate: (value) => (value && value.length > 0 ? undefined : 'Token is required'),
+  })
+  if (isCancel(token)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  return token
+}
+
+async function promptSlackTokens(): Promise<{ bot: string; app: string }> {
+  note(
+    [
+      '1. https://api.slack.com/apps → Create New App → From a manifest.',
+      '   Pick your workspace, then paste this JSON manifest:',
+      '',
+      '   {',
+      '     "display_information": { "name": "TypeClaw" },',
+      '     "features": {',
+      '       "bot_user": { "display_name": "TypeClaw", "always_online": true }',
+      '     },',
+      '     "oauth_config": {',
+      '       "scopes": {',
+      '         "bot": [',
+      '           "app_mentions:read", "chat:write", "users:read", "files:read",',
+      '           "channels:history", "channels:read",',
+      '           "groups:history",   "groups:read",',
+      '           "im:history",       "im:read",',
+      '           "mpim:history",     "mpim:read"',
+      '         ]',
+      '       }',
+      '     },',
+      '     "settings": {',
+      '       "event_subscriptions": {',
+      '         "bot_events": [',
+      '           "app_mention",',
+      '           "message.channels", "message.groups",',
+      '           "message.im",       "message.mpim"',
+      '         ]',
+      '       },',
+      '       "socket_mode_enabled": true',
+      '     }',
+      '   }',
+      '',
+      '2. Install to Workspace, then OAuth & Permissions →',
+      '   copy the Bot User OAuth Token (xoxb-...).',
+      '3. Basic Information → App-Level Tokens → Generate Token and',
+      '   Scopes, add the connections:write scope, and copy the',
+      '   token (xapp-...). Socket Mode needs this; the manifest',
+      '   cannot grant it.',
+      '4. Invite the bot to any private channel or DM you want it in:',
+      '   /invite @TypeClaw',
+    ].join('\n'),
+    'Get a Slack bot',
+  )
+  const botToken = await password({
+    message: 'Slack bot token (xoxb-...)',
+    validate: (value) =>
+      value && value.length > 0
+        ? value.startsWith('xoxb-')
+          ? undefined
+          : 'Bot token must start with "xoxb-"'
+        : 'Token is required',
+  })
+  if (isCancel(botToken)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  note(
+    [
+      'Slack does not accept connections:write inside the manifest, so',
+      'this token has to be generated by hand:',
+      '',
+      '1. Basic Information → App-Level Tokens → Generate Token and Scopes.',
+      '2. Token Name: anything (e.g. "socket-mode").',
+      '3. Add Scope → connections:write → Generate.',
+      '4. Copy the xapp-... token shown once on screen.',
+      '   (You cannot retrieve it later — only revoke and regenerate.)',
+    ].join('\n'),
+    'Generate the Slack app-level token',
+  )
+  const appToken = await password({
+    message: 'Slack app-level token (xapp-...) — Socket Mode requires this',
+    validate: (value) =>
+      value && value.length > 0
+        ? value.startsWith('xapp-')
+          ? undefined
+          : 'App-level token must start with "xapp-"'
+        : 'Token is required',
+  })
+  if (isCancel(appToken)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  return { bot: botToken, app: appToken }
+}
+
+async function promptTelegramToken(): Promise<string> {
+  note(
+    [
+      'Open Telegram and message @BotFather.',
+      '/newbot → pick a name and username, copy the HTTP API token',
+      '  (looks like 1234567890:ABCdef...).',
+      'In @BotFather: /setprivacy → Disable, so the bot can see group messages.',
+    ].join('\n'),
+    'Get a Telegram bot token',
+  )
+  const token = await password({
+    message: 'Telegram bot token',
+    validate: (value) =>
+      value && value.length > 0
+        ? /^\d+:/.test(value)
+          ? undefined
+          : 'Bot token must look like "<digits>:<secret>" (from @BotFather)'
+        : 'Token is required',
+  })
+  if (isCancel(token)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  return token
+}
+
+async function promptKakaotalkCredentials(): Promise<{ email: string; password: string }> {
+  note(
+    [
+      'KakaoTalk authentication uses a personal account, registered as a',
+      'tablet sub-device. Messages will be sent and received under this',
+      'account. Use a non-primary account if possible.',
+      '',
+      'After you submit the password, KakaoTalk may ask you to confirm a',
+      'passcode on your phone. Watch the screen for the code.',
+    ].join('\n'),
+    'About to log in to KakaoTalk',
+  )
+  const email = await text({
+    message: 'KakaoTalk email',
+    validate: (value) => (value && value.length > 0 ? undefined : 'Email is required'),
+  })
+  if (isCancel(email)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  const pwd = await password({
+    message: 'KakaoTalk password',
+    validate: (value) => (value && value.length > 0 ? undefined : 'Password is required'),
+  })
+  if (isCancel(pwd)) {
+    cancel('Aborted.')
+    process.exit(0)
+  }
+  return { email, password: pwd }
+}
+
+function reportProgress(events: AddChannelStepEvent[]): (event: AddChannelStepEvent) => void {
+  const spinners: Partial<Record<AddChannelStepEvent['step'], ReturnType<typeof spinner>>> = {}
+
+  return (event) => {
+    events.push(event)
+    if (event.phase === 'start') {
+      const s = spinner()
+      s.start(START_MESSAGES[event.step])
+      spinners[event.step] = s
+      return
+    }
+
+    const s = spinners[event.step]
+    if (!s) return
+
+    switch (event.step) {
+      case 'kakaotalk-auth':
+        s.stop(reportKakaotalkAuth(event.result))
+        break
+      case 'config':
+        s.stop('Updated typeclaw.json.')
+        break
+      case 'secrets':
+        s.stop('Appended credentials to .env.')
+        break
+    }
+  }
+}
+
+const START_MESSAGES: Record<AddChannelStepEvent['step'], string> = {
+  'kakaotalk-auth': 'Logging in to KakaoTalk...',
+  config: 'Updating typeclaw.json...',
+  secrets: 'Appending credentials to .env...',
+}
+
+function reportKakaotalkAuth(result: KakaotalkAuthResult): string {
+  if (result.ok) return 'KakaoTalk credentials saved to workspace/.agent-messenger/.'
+  return `KakaoTalk login failed: ${result.reason}`
+}
+
+async function maybePromptRestart(cwd: string, channel: ChannelKind): Promise<void> {
+  const label = CHANNEL_LABELS[channel]
+  const current = await status({ cwd }).catch(() => null)
+  if (current === null || current.kind !== 'running') {
+    done({
+      title: c.green(`${label} channel added.`),
+      hints: [
+        { label: 'Start the agent:', command: 'typeclaw start' },
+        { label: 'Then check status:', command: 'typeclaw status' },
+      ],
+    })
+    return
+  }
+
+  const restartNow = await confirm({
+    message:
+      'Channel config is restart-required and the agent container is running. Restart it now to apply the new channel?',
+    initialValue: true,
+  })
+  if (isCancel(restartNow) || !restartNow) {
+    done({
+      title: c.green(`${label} channel added.`),
+      hints: [
+        { label: 'Apply later:', command: 'typeclaw restart' },
+        { label: 'Check status:', command: 'typeclaw status' },
+      ],
+    })
+    return
+  }
+
+  const stopped = await stop({ cwd })
+  if (!stopped.ok) {
+    console.error(errorLine(`Restart failed during stop: ${stopped.reason}`))
+    process.exit(1)
+  }
+  const started = await start({ cwd, preferredHostPort: config.port, cliEntry: process.argv[1] })
+  if (!started.ok) {
+    console.error(errorLine(`Restart failed during start: ${started.reason}`))
+    process.exit(1)
+  }
+  done({
+    title: c.green(`${label} channel added. Restarted ${started.plan.containerName} on host port ${started.hostPort}.`),
+    hints: [
+      { label: 'Attach TUI:', command: 'typeclaw tui' },
+      { label: 'Follow logs:', command: 'typeclaw logs -f' },
+    ],
+  })
+}

package/src/cli/compose-status.ts

@@ -0,0 +1,95 @@
+import { styleText } from 'node:util'
+
+import type { AgentRuntimeState, ComposeStatusResult } from '@/compose'
+
+export type FormatComposeStatusOptions = { useColor?: boolean }
+
+type ColorFn = (s: string) => string
+type Palette = {
+  bold: ColorFn
+  dim: ColorFn
+  green: ColorFn
+  yellow: ColorFn
+  cyan: ColorFn
+}
+
+const identity: ColorFn = (s) => s
+const NO_PALETTE: Palette = {
+  bold: identity,
+  dim: identity,
+  green: identity,
+  yellow: identity,
+  cyan: identity,
+}
+
+const COLOR_PALETTE: Palette = {
+  bold: (s) => styleText('bold', s),
+  dim: (s) => styleText('dim', s),
+  green: (s) => styleText('green', s),
+  yellow: (s) => styleText('yellow', s),
+  cyan: (s) => styleText('cyan', s),
+}
+
+const STATE_LABELS: Record<AgentRuntimeState, string> = {
+  running: 'running',
+  stopped: 'stopped',
+  absent: 'not started',
+}
+
+const STATE_LABEL_WIDTH = Math.max(...Object.values(STATE_LABELS).map((l) => l.length))
+
+export function formatComposeStatus(result: ComposeStatusResult, opts: FormatComposeStatusOptions = {}): string {
+  const useColor = opts.useColor ?? false
+  const p: Palette = useColor ? COLOR_PALETTE : NO_PALETTE
+
+  if (result.entries.length === 0) {
+    return p.dim(`No typeclaw agents in ${result.rootCwd}.`)
+  }
+
+  const nameWidth = result.entries.reduce((w, e) => Math.max(w, e.name.length), 0)
+  const header = p.dim(
+    `${result.entries.length} ${result.entries.length === 1 ? 'agent' : 'agents'} in ${result.rootCwd}`,
+  )
+
+  const lines = [header, '']
+  for (const entry of result.entries) {
+    lines.push(renderRow(entry, nameWidth, p))
+  }
+  return lines.join('\n')
+}
+
+function renderRow(entry: ComposeStatusResult['entries'][number], nameWidth: number, p: Palette): string {
+  const glyph = renderGlyph(entry.state, p)
+  const name = p.bold(entry.name.padEnd(nameWidth))
+  const state = renderState(entry.state, p)
+  const detail = renderDetail(entry, p)
+  return detail ? `  ${glyph}  ${name}  ${state}  ${detail}` : `  ${glyph}  ${name}  ${state}`
+}
+
+function renderGlyph(state: AgentRuntimeState, p: Palette): string {
+  switch (state) {
+    case 'running':
+      return p.green('●')
+    case 'stopped':
+      return p.yellow('○')
+    case 'absent':
+      return p.dim('·')
+  }
+}
+
+function renderState(state: AgentRuntimeState, p: Palette): string {
+  const label = STATE_LABELS[state].padEnd(STATE_LABEL_WIDTH)
+  switch (state) {
+    case 'running':
+      return p.green(label)
+    case 'stopped':
+      return p.yellow(label)
+    case 'absent':
+      return p.dim(label)
+  }
+}
+
+function renderDetail(entry: ComposeStatusResult['entries'][number], p: Palette): string {
+  if (entry.state !== 'running' || entry.hostPort === null) return ''
+  return p.dim('port ') + p.cyan(String(entry.hostPort))
+}