@friendlyrobot/discord-pi-agent 0.1.0

package/README.md

@@ -0,0 +1,105 @@
+# @friendlyrobot/discord-pi-agent
+
+Reusable Discord DM bridge for persistent pi agent sessions.
+
+## What it does
+- runs one long-lived pi agent session
+- resumes the latest session on restart
+- loads project context from the target repo via pi resource loading
+- accepts DM messages from one allowed Discord user
+- serializes prompts through a FIFO queue
+- exposes built-in session commands
+
+## Built-in commands
+- `/help`
+- `/status`
+- `/compact`
+- `/reset-session`
+
+Any other DM text is sent to the persistent agent session.
+
+## Install
+
+```bash
+bun add @friendlyrobot/discord-pi-agent
+```
+
+## Minimal usage
+
+```ts
+import { startDiscordPiBridge } from "@friendlyrobot/discord-pi-agent";
+
+const bridge = await startDiscordPiBridge({
+  discordBotToken: process.env.DISCORD_BOT_TOKEN!,
+  discordAllowedUserId: process.env.DISCORD_ALLOWED_USER_ID!,
+  cwd: process.cwd(),
+  modelProvider: "moonshot-cn",
+  modelId: "kimi-k2.5",
+});
+```
+
+## Usage with dotenv and time context
+
+```ts
+import {
+  buildTimeContextPrompt,
+  loadDiscordPiBridgeConfigFromEnv,
+  startDiscordPiBridge,
+} from "@friendlyrobot/discord-pi-agent";
+
+const config = loadDiscordPiBridgeConfigFromEnv({
+  promptTransform: (input) => {
+    return buildTimeContextPrompt(input, {
+      timeZone: "Australia/Sydney",
+      locale: "en-AU",
+      locationLabel: "Sydney",
+    });
+  },
+});
+
+await startDiscordPiBridge(config);
+```
+
+## Config
+
+### Required
+- `discordBotToken`
+- `discordAllowedUserId`
+- `cwd`
+
+### Optional
+- `agentDir` default: `<cwd>/.pi-agent`
+- `modelProvider` default: `moonshot-cn`
+- `modelId` default: `kimi-k2.5`
+- `promptTransform` default: identity
+- `startupMessage` default: `Bot is online and ready.`
+- `shutdownOnSignals` default: `true`
+
+## Env helper
+
+`loadDiscordPiBridgeConfigFromEnv()` supports:
+
+- `DISCORD_BOT_TOKEN`
+- `DISCORD_ALLOWED_USER_ID`
+- `PI_AGENT_CWD`
+- `PI_AGENT_DIR`
+- `PI_MODEL_PROVIDER`
+- `PI_MODEL_ID`
+- `DISCORD_STARTUP_MESSAGE`
+
+If `PI_AGENT_CWD` is missing it falls back to `process.cwd()`.
+
+Set `DISCORD_STARTUP_MESSAGE=false` to disable the startup DM.
+
+## Build
+
+```bash
+bun run build
+bun run typecheck
+```
+
+## Notes
+- DM-only by design
+- single allowed user by design
+- the package does not register Discord slash commands
+- pi resources are loaded from the configured `cwd` and `agentDir`

package/dist/agent-service.d.ts

@@ -0,0 +1,20 @@
+import type { AgentStatus, ResolvedDiscordPiBridgeConfig } from "./types";
+export declare class AgentService {
+    private readonly config;
+    private readonly authStorage;
+    private readonly modelRegistry;
+    private readonly settingsManager;
+    private readonly resourceLoader;
+    private session;
+    constructor(config: ResolvedDiscordPiBridgeConfig);
+    initialize(): Promise<void>;
+    prompt(text: string): Promise<string>;
+    compact(): Promise<string>;
+    resetSession(): Promise<string>;
+    getStatus(): AgentStatus;
+    shutdown(): Promise<void>;
+    private createOrResumeSession;
+    private ensureConfiguredModel;
+    private requireSession;
+    private getSessionDir;
+}

package/dist/commands.d.ts

@@ -0,0 +1,8 @@
+import type { AgentService } from "./agent-service";
+import type { PromptQueue } from "./prompt-queue";
+type CommandResult = {
+    handled: boolean;
+    response?: string;
+};
+export declare function handleCommand(input: string, agentService: AgentService, promptQueue: PromptQueue): Promise<CommandResult>;
+export {};

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { DiscordPiBridgeConfig, ResolvedDiscordPiBridgeConfig } from "./types";
+export declare function resolveConfig(config: DiscordPiBridgeConfig): ResolvedDiscordPiBridgeConfig;
+export declare function loadDiscordPiBridgeConfigFromEnv(overrides?: Partial<DiscordPiBridgeConfig>): ResolvedDiscordPiBridgeConfig;

package/dist/discord-client.d.ts

@@ -0,0 +1,5 @@
+import { Client } from "discord.js";
+import type { AgentService } from "./agent-service";
+import type { PromptQueue } from "./prompt-queue";
+import type { ResolvedDiscordPiBridgeConfig } from "./types";
+export declare function startDiscordClient(config: ResolvedDiscordPiBridgeConfig, agentService: AgentService, promptQueue: PromptQueue): Promise<Client>;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { DiscordPiBridge, DiscordPiBridgeConfig } from "./types";
+export { buildTimeContextPrompt, type TimeContextPromptOptions } from "./prompt-context";
+export { loadDiscordPiBridgeConfigFromEnv, resolveConfig } from "./config";
+export type { AgentStatus, DiscordPiBridge, DiscordPiBridgeConfig, PromptTransform, ResolvedDiscordPiBridgeConfig, } from "./types";
+export declare function startDiscordPiBridge(config: DiscordPiBridgeConfig): Promise<DiscordPiBridge>;

package/dist/index.js

@@ -0,0 +1,621 @@
+// src/agent-service.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager
+} from "@mariozechner/pi-coding-agent";
+
+// src/reply-buffer.ts
+async function collectReply(session, prompt, options = {}) {
+  const logPrefix = options.logPrefix ?? "[agent]";
+  let streamedText = "";
+  let eventCount = 0;
+  let toolCount = 0;
+  let sawAgentEnd = false;
+  console.log(`${logPrefix} prompt start`, { prompt });
+  const unsubscribe = session.subscribe((event) => {
+    eventCount += 1;
+    if (event.type === "message_update") {
+      if (event.assistantMessageEvent.type === "text_delta") {
+        streamedText += event.assistantMessageEvent.delta;
+      }
+      if (event.assistantMessageEvent.type === "thinking_delta") {}
+    }
+    if (event.type === "tool_execution_start") {
+      toolCount += 1;
+      console.log(`${logPrefix} tool start`, {
+        toolName: event.toolName,
+        input: truncateForLog(JSON.stringify(event.args))
+      });
+    }
+    if (event.type === "tool_execution_end") {
+      console.log(`${logPrefix} tool end`, {
+        toolName: event.toolName,
+        isError: event.isError,
+        output: truncateForLog(extractToolOutput(event.result))
+      });
+    }
+    if (event.type === "agent_end") {
+      sawAgentEnd = true;
+      console.log(`${logPrefix} agent end`, { messageCount: event.messages.length });
+    }
+  });
+  try {
+    await session.prompt(prompt);
+  } finally {
+    unsubscribe();
+  }
+  const errorMessage = session.agent.state.errorMessage?.trim();
+  const fallbackText = getLatestAssistantText(session.messages);
+  const finalText = streamedText.trim() || fallbackText.trim();
+  console.log(`${logPrefix} prompt done`, {
+    eventCount,
+    toolCount,
+    sawAgentEnd,
+    streamedTextLength: streamedText.trim().length,
+    fallbackTextLength: fallbackText.trim().length,
+    errorMessage
+  });
+  if (errorMessage) {
+    return errorMessage;
+  }
+  if (finalText) {
+    return finalText;
+  }
+  return "No response generated.";
+}
+function truncateForLog(value, maxLength = 400) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...`;
+}
+function extractToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  try {
+    return JSON.stringify(output);
+  } catch {
+    return String(output);
+  }
+}
+function getLatestAssistantText(messages) {
+  const latestAssistantMessage = [...messages].reverse().find((message) => {
+    return message.role === "assistant";
+  });
+  if (!latestAssistantMessage || !Array.isArray(latestAssistantMessage.content)) {
+    return "";
+  }
+  return latestAssistantMessage.content.filter((item) => {
+    return item.type === "text";
+  }).map((item) => {
+    return item.text;
+  }).join(`
+`).trim();
+}
+
+// src/agent-service.ts
+class AgentService {
+  config;
+  authStorage;
+  modelRegistry;
+  settingsManager;
+  resourceLoader;
+  session = null;
+  constructor(config) {
+    this.config = config;
+    this.authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
+    this.modelRegistry = ModelRegistry.create(this.authStorage, path.join(config.agentDir, "models.json"));
+    this.settingsManager = SettingsManager.create(config.cwd, config.agentDir);
+    this.resourceLoader = new DefaultResourceLoader({
+      cwd: config.cwd,
+      agentDir: config.agentDir,
+      settingsManager: this.settingsManager
+    });
+  }
+  async initialize() {
+    await fs.mkdir(this.config.agentDir, { recursive: true });
+    await fs.mkdir(this.getSessionDir(), { recursive: true });
+    console.log("[agent] config", {
+      cwd: this.config.cwd,
+      agentDir: this.config.agentDir,
+      sessionDir: this.getSessionDir(),
+      modelProvider: this.config.modelProvider,
+      modelId: this.config.modelId
+    });
+    await this.resourceLoader.reload();
+    console.log("[agent] resources loaded", {
+      extensions: this.resourceLoader.getExtensions().extensions.map((extension) => extension.path),
+      agentsFiles: this.resourceLoader.getAgentsFiles().agentsFiles.map((file) => file.path)
+    });
+    await this.createOrResumeSession();
+    await this.ensureConfiguredModel();
+  }
+  async prompt(text) {
+    const session = this.requireSession();
+    const transformedPrompt = await this.config.promptTransform(text);
+    return collectReply(session, transformedPrompt, { logPrefix: `[agent:${session.sessionId}]` });
+  }
+  async compact() {
+    const session = this.requireSession();
+    await session.compact();
+    return `Compaction finished for session ${session.sessionId}.`;
+  }
+  async resetSession() {
+    const previousSession = this.requireSession();
+    await previousSession.abort();
+    previousSession.dispose();
+    this.session = null;
+    const { session } = await createAgentSession({
+      cwd: this.config.cwd,
+      agentDir: this.config.agentDir,
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader: this.resourceLoader,
+      settingsManager: this.settingsManager,
+      sessionManager: SessionManager.create(this.config.cwd, this.getSessionDir())
+    });
+    this.session = session;
+    await this.ensureConfiguredModel();
+    return `Started a fresh session. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}.`;
+  }
+  getStatus() {
+    const session = this.requireSession();
+    const model = session.model ? `${session.model.provider}/${session.model.id}` : "(no model selected)";
+    return {
+      sessionId: session.sessionId,
+      sessionFile: session.sessionFile,
+      model,
+      streaming: session.isStreaming
+    };
+  }
+  async shutdown() {
+    const session = this.session;
+    if (session) {
+      await session.abort();
+      session.dispose();
+    }
+    await this.settingsManager.flush();
+  }
+  async createOrResumeSession() {
+    const { session } = await createAgentSession({
+      cwd: this.config.cwd,
+      agentDir: this.config.agentDir,
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader: this.resourceLoader,
+      settingsManager: this.settingsManager,
+      sessionManager: SessionManager.continueRecent(this.config.cwd, this.getSessionDir())
+    });
+    this.session = session;
+    console.log("[agent] session ready", {
+      sessionId: session.sessionId,
+      sessionFile: session.sessionFile,
+      restoredModel: session.model ? `${session.model.provider}/${session.model.id}` : null
+    });
+  }
+  async ensureConfiguredModel() {
+    const session = this.requireSession();
+    const desiredModel = this.modelRegistry.find(this.config.modelProvider, this.config.modelId);
+    const availableModels = await this.modelRegistry.getAvailable();
+    console.log("[agent] available models", {
+      count: availableModels.length,
+      matches: availableModels.filter((model) => {
+        return model.provider === this.config.modelProvider;
+      }).map((model) => `${model.provider}/${model.id}`)
+    });
+    if (!desiredModel) {
+      throw new Error(`Configured model not found: ${this.config.modelProvider}/${this.config.modelId}. Check your pi agent config and installed extensions.`);
+    }
+    if (isSameModel(session.model, desiredModel)) {
+      console.log("[agent] model already selected", {
+        model: `${desiredModel.provider}/${desiredModel.id}`
+      });
+      return;
+    }
+    console.log("[agent] switching model", {
+      from: session.model ? `${session.model.provider}/${session.model.id}` : null,
+      to: `${desiredModel.provider}/${desiredModel.id}`
+    });
+    await session.setModel(desiredModel);
+  }
+  requireSession() {
+    if (!this.session) {
+      throw new Error("Agent session has not been initialized.");
+    }
+    return this.session;
+  }
+  getSessionDir() {
+    return path.join(this.config.agentDir, "sessions");
+  }
+}
+function isSameModel(currentModel, desiredModel) {
+  if (!currentModel) {
+    return false;
+  }
+  return currentModel.provider === desiredModel.provider && currentModel.id === desiredModel.id;
+}
+
+// src/config.ts
+import path2 from "node:path";
+import dotenv from "dotenv";
+function resolveConfig(config) {
+  return {
+    discordBotToken: readRequiredValue("discordBotToken", config.discordBotToken),
+    discordAllowedUserId: readRequiredValue("discordAllowedUserId", config.discordAllowedUserId),
+    cwd: readRequiredValue("cwd", config.cwd),
+    agentDir: config.agentDir?.trim() || path2.join(config.cwd, ".pi-agent"),
+    modelProvider: config.modelProvider?.trim() || "moonshot-cn",
+    modelId: config.modelId?.trim() || "kimi-k2.5",
+    promptTransform: config.promptTransform || identityPromptTransform,
+    startupMessage: config.startupMessage === undefined ? "Bot is online and ready." : config.startupMessage,
+    shutdownOnSignals: config.shutdownOnSignals ?? true
+  };
+}
+function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
+  dotenv.config();
+  return resolveConfig({
+    discordBotToken: overrides.discordBotToken || process.env.DISCORD_BOT_TOKEN || "",
+    discordAllowedUserId: overrides.discordAllowedUserId || process.env.DISCORD_ALLOWED_USER_ID || "",
+    cwd: overrides.cwd || process.env.PI_AGENT_CWD || process.cwd(),
+    agentDir: overrides.agentDir || process.env.PI_AGENT_DIR,
+    modelProvider: overrides.modelProvider || process.env.PI_MODEL_PROVIDER,
+    modelId: overrides.modelId || process.env.PI_MODEL_ID,
+    promptTransform: overrides.promptTransform,
+    startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
+    shutdownOnSignals: overrides.shutdownOnSignals
+  });
+}
+function readRequiredValue(name, value) {
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    throw new Error(`Missing required config value: ${name}`);
+  }
+  return trimmedValue;
+}
+function readStartupMessageFromEnv() {
+  const value = process.env.DISCORD_STARTUP_MESSAGE;
+  if (value === undefined) {
+    return;
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue || trimmedValue.toLowerCase() === "false") {
+    return false;
+  }
+  return trimmedValue;
+}
+function identityPromptTransform(input) {
+  return input;
+}
+
+// src/discord-client.ts
+import {
+  ChannelType,
+  Client,
+  Events,
+  GatewayIntentBits,
+  Partials
+} from "discord.js";
+
+// src/commands.ts
+async function handleCommand(input, agentService, promptQueue) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { handled: false };
+  }
+  if (trimmed === "/help") {
+    return {
+      handled: true,
+      response: [
+        "Commands:",
+        "/help - show this message",
+        "/status - show current session status",
+        "/compact - compact the persistent session",
+        "/reset-session - start a fresh persistent session",
+        "Any other DM text goes to the persistent agent session."
+      ].join(`
+`)
+    };
+  }
+  if (trimmed === "/status") {
+    const agentStatus = agentService.getStatus();
+    const queueStatus = promptQueue.getSnapshot();
+    return {
+      handled: true,
+      response: [
+        `model: ${agentStatus.model}`,
+        `session-id: ${agentStatus.sessionId}`,
+        `session-file: ${agentStatus.sessionFile ?? "(none)"}`,
+        `streaming: ${agentStatus.streaming}`,
+        `queue-pending: ${queueStatus.pending}`,
+        `queue-busy: ${queueStatus.busy}`
+      ].join(`
+`)
+    };
+  }
+  if (trimmed === "/compact") {
+    return {
+      handled: true,
+      response: await promptQueue.enqueue(async () => {
+        return agentService.compact();
+      })
+    };
+  }
+  if (trimmed === "/reset-session") {
+    return {
+      handled: true,
+      response: await promptQueue.enqueue(async () => {
+        return agentService.resetSession();
+      })
+    };
+  }
+  return {
+    handled: true,
+    response: `Unknown command: ${trimmed}. Try /help.`
+  };
+}
+
+// src/message-chunker.ts
+var DISCORD_MESSAGE_LIMIT = 2000;
+var SAFE_MESSAGE_LIMIT = 1900;
+function chunkMessage(text) {
+  if (text.length <= SAFE_MESSAGE_LIMIT) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > SAFE_MESSAGE_LIMIT) {
+    const candidate = remaining.slice(0, SAFE_MESSAGE_LIMIT);
+    const splitIndex = Math.max(candidate.lastIndexOf(`
+
+`), candidate.lastIndexOf(`
+`), candidate.lastIndexOf(" "));
+    const boundary = splitIndex > 0 ? splitIndex : SAFE_MESSAGE_LIMIT;
+    chunks.push(remaining.slice(0, boundary).trim());
+    remaining = remaining.slice(boundary).trim();
+  }
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+  return chunks.filter((chunk) => chunk.length > 0).map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
+}
+
+// src/discord-client.ts
+async function startDiscordClient(config, agentService, promptQueue) {
+  const client = new Client({
+    intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+    partials: [Partials.Channel]
+  });
+  client.once(Events.ClientReady, async (readyClient) => {
+    console.log(`[discord] logged in as ${readyClient.user.tag}`);
+    if (!config.startupMessage) {
+      return;
+    }
+    try {
+      const user = await readyClient.users.fetch(config.discordAllowedUserId);
+      const dmChannel = await user.createDM();
+      await dmChannel.send(config.startupMessage);
+      console.log("[discord] sent startup dm", {
+        userId: config.discordAllowedUserId
+      });
+    } catch (error) {
+      console.error("[discord] failed to send startup dm", error);
+    }
+  });
+  client.on(Events.MessageCreate, async (message) => {
+    console.log("[discord] message received", {
+      messageId: message.id,
+      authorId: message.author.id,
+      channelType: message.channel.type,
+      content: message.content
+    });
+    try {
+      await onMessage(message, config, agentService, promptQueue);
+    } catch (error) {
+      console.error("[discord] message handling failed", error);
+      await sendReply(message, "The bot hit an error while handling that message.");
+    }
+  });
+  await client.login(config.discordBotToken);
+  return client;
+}
+async function onMessage(message, config, agentService, promptQueue) {
+  if (message.author.bot) {
+    console.log("[discord] ignored bot message", { messageId: message.id });
+    return;
+  }
+  if (message.author.id !== config.discordAllowedUserId) {
+    console.log("[discord] ignored unauthorized user", {
+      messageId: message.id,
+      authorId: message.author.id
+    });
+    return;
+  }
+  if (message.channel.type !== ChannelType.DM) {
+    console.log("[discord] ignored non-dm message", {
+      messageId: message.id,
+      channelType: message.channel.type
+    });
+    return;
+  }
+  const content = message.content.trim();
+  if (!content) {
+    console.log("[discord] ignored empty message", { messageId: message.id });
+    return;
+  }
+  const commandResult = await handleCommand(content, agentService, promptQueue);
+  if (commandResult.handled) {
+    console.log("[discord] command handled", {
+      messageId: message.id,
+      command: content,
+      hasResponse: Boolean(commandResult.response)
+    });
+    if (commandResult.response) {
+      await sendReply(message, commandResult.response);
+    }
+    return;
+  }
+  if (!message.channel.isSendable()) {
+    console.log("[discord] channel is not sendable", { messageId: message.id });
+    return;
+  }
+  await message.channel.sendTyping();
+  const queuePosition = promptQueue.getSnapshot().pending;
+  console.log("[queue] enqueue request", {
+    messageId: message.id,
+    queuePosition
+  });
+  if (queuePosition > 0) {
+    await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
+  }
+  const response = await promptQueue.enqueue(async () => {
+    console.log(`[queue] processing message ${message.id}`);
+    return agentService.prompt(content);
+  });
+  console.log("[discord] response ready", {
+    messageId: message.id,
+    responseLength: response.length,
+    preview: response.slice(0, 200)
+  });
+  await sendReply(message, response);
+}
+async function sendReply(message, text) {
+  if (!message.channel.isSendable()) {
+    console.log("[discord] reply skipped, channel not sendable", { messageId: message.id });
+    return;
+  }
+  const chunks = chunkMessage(text);
+  console.log("[discord] sending reply", {
+    messageId: message.id,
+    chunkCount: chunks.length,
+    textLength: text.length
+  });
+  const [firstChunk, ...remainingChunks] = chunks;
+  if (!firstChunk) {
+    return;
+  }
+  await message.reply(firstChunk);
+  for (const chunk of remainingChunks) {
+    await message.channel.send(chunk);
+  }
+}
+
+// src/prompt-queue.ts
+class PromptQueue {
+  queue = [];
+  running = false;
+  enqueue(task) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          resolve(await task());
+        } catch (error) {
+          reject(error);
+        }
+      });
+      this.kick();
+    });
+  }
+  getSnapshot() {
+    return {
+      pending: this.queue.length,
+      busy: this.running
+    };
+  }
+  kick() {
+    if (this.running) {
+      return;
+    }
+    const next = this.queue.shift();
+    if (!next) {
+      return;
+    }
+    this.running = true;
+    next().finally(() => {
+      this.running = false;
+      this.kick();
+    });
+  }
+}
+
+// src/prompt-context.ts
+function buildTimeContextPrompt(userMessage, options = {}) {
+  const timeZone = options.timeZone || "UTC";
+  const locale = options.locale || "en-AU";
+  const locationLabel = options.locationLabel || timeZone;
+  const now = options.now || new Date;
+  const localTime = new Intl.DateTimeFormat(locale, {
+    timeZone,
+    day: "numeric",
+    month: "short",
+    year: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).format(now);
+  const trimmedMessage = userMessage.trim();
+  return [`Local time: ${localTime}, ${locationLabel}`, "", "User message:", trimmedMessage].join(`
+`);
+}
+
+// src/index.ts
+async function startDiscordPiBridge(config) {
+  const resolvedConfig = resolveConfig(config);
+  const agentService = new AgentService(resolvedConfig);
+  const promptQueue = new PromptQueue;
+  console.log("[boot] initializing persistent agent session");
+  await agentService.initialize();
+  console.log("[boot] agent ready", agentService.getStatus());
+  const client = await startDiscordClient(resolvedConfig, agentService, promptQueue);
+  const stop = createStopHandler(client, agentService, resolvedConfig);
+  if (resolvedConfig.shutdownOnSignals) {
+    registerSignalHandlers(stop);
+  }
+  return {
+    client,
+    stop,
+    getStatus: () => {
+      return agentService.getStatus();
+    }
+  };
+}
+function createStopHandler(client, agentService, config) {
+  let stopped = false;
+  return async () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    console.log("[shutdown] stopping discord pi bridge", {
+      cwd: config.cwd,
+      agentDir: config.agentDir
+    });
+    client.destroy();
+    await agentService.shutdown();
+  };
+}
+function registerSignalHandlers(stop) {
+  const handleSignal = (signal) => {
+    stop().finally(() => {
+      console.log(`[shutdown] received ${signal}`);
+    });
+  };
+  process.on("SIGINT", () => {
+    handleSignal("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    handleSignal("SIGTERM");
+  });
+}
+export {
+  startDiscordPiBridge,
+  resolveConfig,
+  loadDiscordPiBridgeConfigFromEnv,
+  buildTimeContextPrompt
+};

package/dist/message-chunker.d.ts

@@ -0,0 +1 @@
+export declare function chunkMessage(text: string): string[];

package/dist/prompt-context.d.ts

@@ -0,0 +1,7 @@
+export type TimeContextPromptOptions = {
+    timeZone?: string;
+    locale?: string;
+    locationLabel?: string;
+    now?: Date;
+};
+export declare function buildTimeContextPrompt(userMessage: string, options?: TimeContextPromptOptions): string;

package/dist/prompt-queue.d.ts

@@ -0,0 +1,13 @@
+type QueueTask<T> = () => Promise<T>;
+type QueueSnapshot = {
+    pending: number;
+    busy: boolean;
+};
+export declare class PromptQueue {
+    private readonly queue;
+    private running;
+    enqueue<T>(task: QueueTask<T>): Promise<T>;
+    getSnapshot(): QueueSnapshot;
+    private kick;
+}
+export {};

package/dist/reply-buffer.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+type CollectReplyOptions = {
+    logPrefix?: string;
+};
+export declare function collectReply(session: AgentSession, prompt: string, options?: CollectReplyOptions): Promise<string>;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+import type { Client } from "discord.js";
+export type PromptTransform = (input: string) => string | Promise<string>;
+export type DiscordPiBridgeConfig = {
+    discordBotToken: string;
+    discordAllowedUserId: string;
+    cwd: string;
+    agentDir?: string;
+    modelProvider?: string;
+    modelId?: string;
+    promptTransform?: PromptTransform;
+    startupMessage?: string | false;
+    shutdownOnSignals?: boolean;
+};
+export type ResolvedDiscordPiBridgeConfig = {
+    discordBotToken: string;
+    discordAllowedUserId: string;
+    cwd: string;
+    agentDir: string;
+    modelProvider: string;
+    modelId: string;
+    promptTransform: PromptTransform;
+    startupMessage: string | false;
+    shutdownOnSignals: boolean;
+};
+export type AgentStatus = {
+    sessionId: string;
+    sessionFile: string | undefined;
+    model: string;
+    streaming: boolean;
+};
+export type DiscordPiBridge = {
+    client: Client;
+    stop: () => Promise<void>;
+    getStatus: () => AgentStatus;
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@friendlyrobot/discord-pi-agent",
+  "version": "0.1.0",
+  "description": "Reusable Discord gateway bridge for persistent pi agent sessions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.json --emitDeclarationOnly --declaration --declarationMap false",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "latest",
+    "@mariozechner/pi-coding-agent": "latest",
+    "discord.js": "^14.19.3",
+    "dotenv": "^16.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  }
+}