@p-sw/brainbox 0.1.0

package/src/channel/discord.ts

@@ -0,0 +1,227 @@
+import {
+  Client,
+  Events,
+  GatewayIntentBits,
+  type SendableChannels,
+} from "discord.js";
+import type { AvailabilityStatus } from "@/provider/schema";
+import { logger } from "@/utils/logger";
+import { BaseChannel, type PairingEntry, type PairingInbound } from "./base";
+import type { BrainItemDiscord } from "@/brain/manager";
+import type { Brain } from "@/brain";
+import type { MessageHistoryEntry } from "@/brain/messageHistory";
+
+const HISTORY_CAP = 1000;
+const AVAILABILITY_STATUS_MAP: Record<
+  AvailabilityStatus,
+  "online" | "dnd" | "invisible"
+> = {
+  online: "online",
+  "do-not-disturb": "dnd",
+  offline: "invisible",
+};
+
+export class DiscordChannel extends BaseChannel<BrainItemDiscord> {
+  private client?: Client;
+  private targetChannel?: SendableChannels;
+  private history: MessageHistoryEntry[] = [];
+
+  constructor(brain: Brain<BrainItemDiscord>) {
+    super(brain);
+  }
+
+  async init(): Promise<void> {
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent, // ponytail: privileged intent — required for msg.content; disable if unavailable, text will be empty
+      ],
+    });
+    if (this.brain.brainbase.discord.channelId) {
+      this.isReady = true;
+      logger.debug(
+        `DiscordChannel.init: pre-bound channelId=${this.brain.brainbase.discord.channelId}`,
+      );
+    } else {
+      this.engagePairing();
+      logger.debug(`DiscordChannel.init: entering pairing mode`);
+    }
+    this.registerActive();
+    this.client.once(Events.ClientReady, (c) => {
+      logger.success(`Discord ready as ${c.user.tag}`);
+      const channelId = this.brain.brainbase.discord.channelId;
+      if (channelId && !this.targetChannel) {
+        logger.debug(`DiscordClientReady: resolving configured channel ${channelId}`);
+        void this.resolveConfiguredChannel(channelId);
+      }
+    });
+    this.client.on(Events.MessageCreate, (msg) => {
+      if (msg.author.bot) return;
+      const content = msg.content;
+      if (!content) return;
+      const channelId = this.brain.brainbase.discord.channelId;
+      if (channelId !== undefined && msg.channelId !== channelId) {
+        logger.debug(
+          `MessageCreate: ignoring from channel=${msg.channelId} (not bound)`,
+        );
+        return;
+      }
+      const inbound: PairingInbound = {
+        content,
+        time: msg.createdAt,
+        replyTo: msg.id,
+        channelId: msg.channelId,
+      };
+      if (channelId === undefined) {
+        logger.debug(`MessageCreate: routing to pairing (no channelId bound)`);
+        void this.onPairing(inbound);
+        return;
+      }
+      const entry: MessageHistoryEntry = {
+        sender: "user",
+        time: msg.createdAt,
+        content,
+      };
+      this.pushHistory(entry);
+      logger.debug(
+        `MessageCreate: stored in history, dispatching (channel=${msg.channelId})`,
+      );
+      void this.onMessage(entry);
+    });
+    logger.debug(`DiscordChannel.init: logging in`);
+    await this.client.login(this.brain.brainbase.discord.token);
+  }
+
+  protected async sendPairingReply(
+    text: string,
+    inbound: PairingInbound,
+  ): Promise<void> {
+    if (!this.client || inbound.channelId === undefined) {
+      logger.debug(`sendPairingReply: no client or channelId, skip`);
+      return;
+    }
+    const channel = await this.client.channels.fetch(inbound.channelId);
+    if (!channel || !channel.isSendable()) {
+      logger.debug(
+        `sendPairingReply: channel ${inbound.channelId} not sendable`,
+      );
+      return;
+    }
+    logger.debug(`sendPairingReply: posting to ${inbound.channelId}`);
+    await channel.send({
+      content: text,
+      ...(inbound.replyTo
+        ? { reply: { messageReference: inbound.replyTo } }
+        : {}),
+    });
+  }
+
+  protected override async completePairing(entry: PairingEntry): Promise<void> {
+    if (entry.channelId !== undefined) {
+      this.brain.brainbase.discord.channelId = entry.channelId;
+      await this.brain.persistBrainBase();
+      this.targetChannel = undefined;
+      if (this.client) {
+        const channel = await this.client.channels.fetch(entry.channelId);
+        if (channel && channel.isSendable()) {
+          this.targetChannel = channel;
+        }
+      }
+      logger.success(
+        `Discord channel bound: ${this.brain.brainbase.displayName} → ${entry.channelId}`,
+      );
+    }
+    await super.completePairing(entry);
+  }
+
+  async send(text: string, opts?: { replyTo?: string }): Promise<void> {
+    const channel = await this.resolveSendChannel();
+    if (!channel) {
+      throw new Error(
+        "DiscordChannel.send: no channel yet (no inbound message)",
+      );
+    }
+    logger.debug(
+      `send: posting ${text.length} chars${opts?.replyTo ? ` (reply to ${opts.replyTo})` : ""}`,
+    );
+    if (opts?.replyTo) {
+      await channel.send({
+        content: text,
+        reply: { messageReference: opts.replyTo },
+      });
+    } else {
+      await channel.send(text);
+    }
+  }
+
+  async setAvailability(status: AvailabilityStatus): Promise<void> {
+    if (!this.client?.user) {
+      logger.debug(`setAvailability: no client/user, skip`);
+      return;
+    }
+    const mapped = AVAILABILITY_STATUS_MAP[status];
+    logger.debug(`setAvailability: ${status} → ${mapped}`);
+    this.client.user.setStatus(mapped);
+  }
+
+  async getMessageHistoryBetween(
+    start: Date,
+    end: Date,
+  ): Promise<ReadonlyArray<MessageHistoryEntry>> {
+    return this.history.filter((m) => m.time >= start && m.time <= end);
+  }
+
+  private pushHistory(entry: MessageHistoryEntry): void {
+    this.history.push(entry);
+    if (this.history.length > HISTORY_CAP) this.history.shift();
+  }
+
+  private async resolveSendChannel(): Promise<SendableChannels | undefined> {
+    if (this.targetChannel) {
+      logger.debug(`resolveSendChannel: cache hit`);
+      return this.targetChannel;
+    }
+    if (!this.client?.isReady()) {
+      logger.debug(`resolveSendChannel: client not ready, returning undefined`);
+      return undefined;
+    }
+    const channelId = this.brain.brainbase.discord.channelId;
+    if (!channelId) {
+      logger.debug(`resolveSendChannel: no channelId bound`);
+      return undefined;
+    }
+    logger.debug(`resolveSendChannel: fetching ${channelId}`);
+    const channel = await this.client.channels.fetch(channelId);
+    if (channel && channel.isSendable()) {
+      this.targetChannel = channel;
+      logger.debug(`resolveSendChannel: cached`);
+    } else {
+      logger.debug(`resolveSendChannel: ${channelId} not sendable`);
+    }
+    return this.targetChannel;
+  }
+
+  private async resolveConfiguredChannel(channelId: string): Promise<void> {
+    if (!this.client) {
+      logger.debug(`resolveConfiguredChannel: no client`);
+      return;
+    }
+    logger.debug(`resolveConfiguredChannel: fetching ${channelId}`);
+    const channel = await this.client.channels.fetch(channelId);
+    if (channel && channel.isSendable()) {
+      this.targetChannel = channel;
+      logger.debug(`resolveConfiguredChannel: cached`);
+    } else {
+      logger.debug(`resolveConfiguredChannel: ${channelId} not sendable`);
+    }
+  }
+
+  protected async teardownClient(): Promise<void> {
+    logger.debug(`teardownClient: destroying discord client`);
+    this.client?.destroy();
+    this.client = undefined;
+    this.targetChannel = undefined;
+  }
+}

package/src/channel/telegram.ts

@@ -0,0 +1,150 @@
+import { Bot } from "gramio";
+import type { AvailabilityStatus } from "@/provider/schema";
+import { logger } from "@/utils/logger";
+import { BaseChannel, type PairingInbound, type PairingEntry } from "./base";
+import type { BrainItemTelegram } from "@/brain/manager";
+import type { Brain } from "@/brain";
+import type { MessageHistoryEntry } from "@/brain/messageHistory";
+
+const HISTORY_CAP = 1000;
+
+export class TelegramChannel extends BaseChannel<BrainItemTelegram> {
+  private bot?: Bot;
+  private chatId?: number;
+  private history: MessageHistoryEntry[] = [];
+
+  constructor(brain: Brain<BrainItemTelegram>) {
+    super(brain);
+  }
+
+  async init(): Promise<void> {
+    this.bot = new Bot(this.brain.brainbase.telegram.token);
+    this.chatId = this.brain.brainbase.telegram.chatId;
+    if (this.chatId !== undefined) {
+      this.isReady = true;
+      logger.debug(
+        `TelegramChannel.init: pre-bound chatId=${this.chatId}`,
+      );
+    } else {
+      this.engagePairing();
+      logger.debug(`TelegramChannel.init: entering pairing mode`);
+    }
+    this.registerActive();
+    this.bot.onStart(({ info }) => {
+      logger.success(`Telegram ready as @${info.username}`);
+    });
+    this.bot.on("message", (ctx) => {
+      if (ctx.from?.isBot()) return;
+      const text = ctx.text;
+      if (!text) return;
+      const chatId = this.brain.brainbase.telegram.chatId;
+      if (chatId !== undefined && ctx.chat.id !== chatId) {
+        logger.debug(
+          `Telegram message: ignoring chat=${ctx.chat.id} (not bound to ${chatId})`,
+        );
+        return;
+      }
+      const inbound: PairingInbound = {
+        content: text,
+        time: new Date(ctx.createdAt * 1000),
+        replyTo: String(ctx.id),
+        chatId: ctx.chat.id,
+      };
+      if (chatId === undefined) {
+        logger.debug(
+          `Telegram message: routing to pairing (no chatId bound)`,
+        );
+        void this.onPairing(inbound);
+        return;
+      }
+      this.chatId = ctx.chat.id;
+      const entry: MessageHistoryEntry = {
+        sender: "user",
+        time: inbound.time,
+        content: text,
+      };
+      this.pushHistory(entry);
+      logger.debug(
+        `Telegram message: stored in history, dispatching (chat=${ctx.chat.id})`,
+      );
+      void this.onMessage(entry);
+    });
+    logger.debug(`TelegramChannel.init: starting bot`);
+    await this.bot.start();
+  }
+
+  protected async sendPairingReply(
+    text: string,
+    inbound: PairingInbound,
+  ): Promise<void> {
+    if (!this.bot || inbound.chatId === undefined) {
+      logger.debug(`sendPairingReply: no bot or chatId, skip`);
+      return;
+    }
+    logger.debug(`sendPairingReply: posting to ${inbound.chatId}`);
+    await this.bot.api.sendMessage({
+      chat_id: inbound.chatId,
+      text,
+      ...(inbound.replyTo
+        ? { reply_parameters: { message_id: Number(inbound.replyTo) } }
+        : {}),
+    });
+  }
+
+  protected override async completePairing(entry: PairingEntry): Promise<void> {
+    if (entry.chatId !== undefined) {
+      this.brain.brainbase.telegram.chatId = entry.chatId;
+      this.chatId = entry.chatId;
+      await this.brain.persistBrainBase();
+      logger.success(
+        `Telegram chat bound: ${this.brain.brainbase.displayName} → ${entry.chatId}`,
+      );
+    }
+    await super.completePairing(entry);
+  }
+
+  async send(text: string, opts?: { replyTo?: string }): Promise<void> {
+    if (!this.bot || this.chatId === undefined) {
+      throw new Error("TelegramChannel.send: no chat yet (no inbound message)");
+    }
+    logger.debug(
+      `send: posting ${text.length} chars${opts?.replyTo ? ` (reply to ${opts.replyTo})` : ""}`,
+    );
+    await this.bot.api.sendMessage({
+      chat_id: this.chatId,
+      text,
+      ...(opts?.replyTo
+        ? { reply_parameters: { message_id: Number(opts.replyTo) } }
+        : {}),
+    });
+  }
+
+  async setAvailability(_status: AvailabilityStatus): Promise<void> {
+    logger.debug(
+      `setAvailability: ${_status} (no-op, Telegram has no bot presence)`,
+    );
+    // ponytail: Telegram Bot API exposes no bot presence concept — no-op.
+  }
+
+  async getMessageHistoryBetween(
+    start: Date,
+    end: Date,
+  ): Promise<ReadonlyArray<MessageHistoryEntry>> {
+    return this.history.filter((m) => m.time >= start && m.time <= end);
+  }
+
+  private pushHistory(entry: MessageHistoryEntry): void {
+    this.history.push(entry);
+    if (this.history.length > HISTORY_CAP) this.history.shift();
+  }
+
+  protected async teardownClient(): Promise<void> {
+    if (!this.bot) {
+      logger.debug(`teardownClient: no bot, nothing to stop`);
+      return;
+    }
+    logger.debug(`teardownClient: stopping telegram bot`);
+    await this.bot.stop(1000);
+    this.bot = undefined;
+  }
+}

package/src/commands/auth.tsx

@@ -0,0 +1,306 @@
+import { useState } from "react";
+import { Box, Text, render } from "ink";
+import type { Command } from "commander";
+import { logger } from "@/utils/logger";
+import { TextInput } from "@/ui/TextInput";
+import { listProviderNames } from "@/provider/llm";
+import {
+  PROVIDER_EXTRA_FIELDS,
+  readAuthFile,
+  removeProviderAuth,
+  setProviderAuth,
+} from "@/config/file/auth";
+import { registerCommand } from "@/commands";
+
+type Stage =
+  | { kind: "provider" }
+  | { kind: "apiKey"; provider: string }
+  | {
+      kind: "extras";
+      provider: string;
+      fields: string[];
+      values: Record<string, string>;
+    };
+
+function maskKey(key: string): string {
+  if (key.length <= 8) return "****";
+  return `${key.slice(0, 4)}****${key.slice(-4)}`;
+}
+
+function ProviderPicker({
+  providers,
+  onSelect,
+}: {
+  providers: string[];
+  onSelect: (provider: string) => void;
+}): React.ReactElement {
+  return (
+    <Box flexDirection="column">
+      <TextInput
+        prompt="provider: "
+        onSubmit={(v) => onSelect(v.trim())}
+      />
+      <Text dimColor>
+        matches ({providers.length}/{providers.length}):
+      </Text>
+      {providers.slice(0, 8).map((p) => (
+        <Text key={p}>  - {p}</Text>
+      ))}
+      {providers.length > 8 && <Text dimColor>  ... and more</Text>}
+    </Box>
+  );
+}
+
+function AddApp({
+  providers,
+  initialProvider,
+  onDone,
+}: {
+  providers: string[];
+  initialProvider?: string;
+  onDone: () => void;
+}): React.ReactElement {
+  const [stage, setStage] = useState<Stage>(
+    initialProvider
+      ? { kind: "apiKey", provider: initialProvider }
+      : { kind: "provider" },
+  );
+  const [error, setError] = useState<string | null>(null);
+
+  if (stage.kind === "provider") {
+    return (
+      <Box flexDirection="column">
+        <Text>Select a provider to add:</Text>
+        <Text dimColor>(Enter an exact provider name; see list below)</Text>
+        <ProviderPicker
+          providers={providers}
+          onSelect={(p) => {
+            if (!p) {
+              setError("Provider name is required");
+              return;
+            }
+            if (!providers.includes(p)) {
+              setError(`Unknown provider "${p}"`);
+              return;
+            }
+            setError(null);
+            setStage({ kind: "apiKey", provider: p });
+          }}
+        />
+        {error && <Text color="red">{error}</Text>}
+      </Box>
+    );
+  }
+
+  if (stage.kind === "apiKey") {
+    return (
+      <Box flexDirection="column">
+        <Text>
+          Provider: <Text color="cyan">{stage.provider}</Text>
+        </Text>
+        <TextInput
+          prompt={`${stage.provider} apiKey: `}
+          onSubmit={(apiKey) => {
+            const trimmed = apiKey.trim();
+            if (!trimmed) {
+              setError("apiKey cannot be empty");
+              return;
+            }
+            const extras = PROVIDER_EXTRA_FIELDS[stage.provider] ?? [];
+            if (extras.length === 0) {
+              setProviderAuth(stage.provider, { apiKey: trimmed });
+              logger.success(`Saved ${stage.provider} to auth.yaml`);
+              onDone();
+              return;
+            }
+            setError(null);
+            setStage({
+              kind: "extras",
+              provider: stage.provider,
+              fields: extras,
+              values: { apiKey: trimmed },
+            });
+          }}
+        />
+        {error && <Text color="red">{error}</Text>}
+      </Box>
+    );
+  }
+
+  // stage.kind === "extras"
+  const nextField = stage.fields[0];
+  if (!nextField) {
+    setProviderAuth(stage.provider, stage.values);
+    logger.success(`Saved ${stage.provider} to auth.yaml`);
+    return <Text>Done.</Text>;
+  }
+  return (
+    <Box flexDirection="column">
+      <Text>
+        {stage.provider}: <Text color="cyan">{stage.values["apiKey"]}</Text>
+      </Text>
+      <Text>Optional fields remaining: {stage.fields.join(", ")}</Text>
+      <TextInput
+        prompt={`${nextField} (leave empty to skip): `}
+        onSubmit={(raw) => {
+          const value = raw.trim();
+          const remaining = stage.fields.slice(1);
+          const values: Record<string, string> = { ...stage.values };
+          if (value) values[nextField] = value;
+          setStage({
+            kind: "extras",
+            provider: stage.provider,
+            fields: remaining,
+            values,
+          });
+        }}
+      />
+    </Box>
+  );
+}
+
+function ListApp(): React.ReactElement {
+  const auth = readAuthFile();
+  const names = Object.keys(auth).sort();
+  if (names.length === 0) {
+    return (
+      <Text>
+        No providers configured. Run <Text color="cyan">brainbox auth add</Text>{" "}
+        to add one.
+      </Text>
+    );
+  }
+  return (
+    <Box flexDirection="column">
+      <Text>Configured providers ({names.length}):</Text>
+      {names.map((name) => {
+        const fields = auth[name] ?? {};
+        const fieldList = Object.entries(fields)
+          .map(
+            ([k, v]) =>
+              `${k}=${k === "apiKey" ? maskKey(String(v)) : String(v)}`,
+          )
+          .join(", ");
+        return (
+          <Text key={name}>
+            {"  "}- <Text color="cyan">{name}</Text>: {fieldList}
+          </Text>
+        );
+      })}
+    </Box>
+  );
+}
+
+function RemoveApp({
+  providers,
+  onDone,
+}: {
+  providers: string[];
+  onDone: () => void;
+}): React.ReactElement {
+  const [picked, setPicked] = useState<string | null>(null);
+  if (!picked) {
+    return (
+      <Box flexDirection="column">
+        <Text>Select a provider to remove:</Text>
+        <ProviderPicker
+          providers={providers}
+          onSelect={(p) => {
+            if (!providers.includes(p)) {
+              logger.error(`Provider "${p}" is not configured.`);
+              process.exit(1);
+            }
+            setPicked(p);
+          }}
+        />
+      </Box>
+    );
+  }
+  return (
+    <Box flexDirection="column">
+      <Text>
+        Confirm remove <Text color="cyan">{picked}</Text> (yes/no):
+      </Text>
+      <TextInput
+        prompt="> "
+        onSubmit={(v) => {
+          if (v.trim().toLowerCase() !== "yes") {
+            logger.info("Cancelled.");
+            onDone();
+            return;
+          }
+          removeProviderAuth(picked);
+          logger.success(`Removed ${picked} from auth.yaml`);
+          onDone();
+        }}
+      />
+    </Box>
+  );
+}
+
+async function runAdd(providerArg?: string): Promise<void> {
+  const providers = listProviderNames().slice().sort();
+  if (providerArg && !providers.includes(providerArg)) {
+    logger.error(
+      `Unknown provider "${providerArg}". Registered: ${providers.join(", ")}`,
+    );
+    process.exit(1);
+  }
+  const app = render(
+    <AddApp
+      providers={providers}
+      initialProvider={providerArg}
+      onDone={() => app.unmount()}
+    />,
+  );
+  await app.waitUntilExit();
+}
+
+async function runList(): Promise<void> {
+  const app = render(<ListApp />);
+  // ponytail: list is read-only, no input needed — unmount on next tick.
+  setImmediate(() => app.unmount());
+  await app.waitUntilExit();
+}
+
+async function runRemove(): Promise<void> {
+  const auth = readAuthFile();
+  const configured = Object.keys(auth).sort();
+  if (configured.length === 0) {
+    logger.info("No providers configured. Nothing to remove.");
+    return;
+  }
+  const app = render(
+    <RemoveApp providers={configured} onDone={() => app.unmount()} />,
+  );
+  await app.waitUntilExit();
+}
+
+export function register(program: Command): Command {
+  return registerCommand(program, {
+    name: "auth",
+    description: "Manage provider authentication in auth.yaml",
+    configure: (cmd) => {
+      cmd
+        .command("add [provider]")
+        .description("Add provider authentication (interactive)")
+        .action(async (provider?: string) => {
+          await runAdd(provider);
+        });
+      cmd
+        .command("list")
+        .description("List configured providers")
+        .action(async () => {
+          await runList();
+        });
+      cmd
+        .command("remove")
+        .alias("rm")
+        .description("Remove provider authentication (interactive)")
+        .action(async () => {
+          await runRemove();
+        });
+      return cmd;
+    },
+  });
+}