pi-discord-bot 0.1.1

package/dist/main.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { getOrCreateRunner } from "./agent.js";
+import { DiscordBot } from "./discord.js";
+import * as log from "./log.js";
+import { ChannelStore } from "./store.js";
+const token = process.env.DISCORD_TOKEN;
+const configuredWorkingDir = process.argv[2] ?? process.env.PI_DISCORD_BOT_WORKDIR;
+const defaultWorkingDir = join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "pi-discord-bot", "agent");
+const workingDir = resolve(configuredWorkingDir ?? defaultWorkingDir);
+if (!token) {
+    console.error("Missing DISCORD_TOKEN");
+    process.exit(1);
+}
+const rootDir = workingDir;
+const states = new Map();
+function getConversationKey(event) {
+    if (event.threadId && event.guildId)
+        return `guild:${event.guildId}:thread:${event.threadId}`;
+    if (event.guildId)
+        return `guild:${event.guildId}:channel:${event.channelId}`;
+    return `dm:${event.userId}`;
+}
+function getState(event) {
+    const key = getConversationKey(event);
+    let state = states.get(key);
+    if (!state) {
+        state = {
+            running: false,
+            runner: getOrCreateRunner(rootDir, key),
+            stopRequested: false,
+        };
+        states.set(key, state);
+    }
+    return state;
+}
+let bot;
+function helpText() {
+    return [
+        "Commands:",
+        "- /new",
+        "- /name <name>",
+        "- /session",
+        "- /tree",
+        "- /tree <entryId>",
+        "- /model",
+        "- /model <provider/model-or-search>",
+        "- /scoped-models",
+        "- /scoped-models <pattern[,pattern...]>",
+        "- /settings",
+        "- /compact [instructions]",
+        "- /reload",
+        "- /login [provider]",
+        "- /logout [provider]",
+        "- /stop",
+        "Unsupported in Discord: /resume, /fork, /copy, /export, /share, /hotkeys, /changelog, /quit, /exit",
+    ].join("\n");
+}
+function isUiCommand(command) {
+    return new Set([
+        "/help",
+        "/new",
+        "/name",
+        "/session",
+        "/model",
+        "/scoped-models",
+        "/settings",
+        "/compact",
+        "/reload",
+        "/login",
+        "/logout",
+        "/resume",
+        "/tree",
+        "/fork",
+        "/copy",
+        "/export",
+        "/share",
+        "/hotkeys",
+        "/changelog",
+        "/quit",
+        "/exit",
+    ]).has(command);
+}
+async function handleCommand(event, transport) {
+    const text = event.text.trim();
+    if (!text.startsWith("/"))
+        return false;
+    const ctx = await transport.createContext(event);
+    const state = getState(event);
+    const [command, ...rest] = text.split(/\s+/);
+    const args = rest.join(" ").trim();
+    if (event.source === "slash" && isUiCommand(command)) {
+        await ctx.setWorking(false);
+    }
+    if (state.running && command !== "/stop") {
+        await ctx.replaceMessage("Already working. Use /stop first, then retry your command.");
+        return true;
+    }
+    switch (command) {
+        case "/help":
+            await ctx.replaceMessage(helpText());
+            return true;
+        case "/new":
+            await state.runner.newSession();
+            await ctx.replaceMessage(`Started a new session. Current model: ${state.runner.currentModel()}`);
+            return true;
+        case "/name":
+            if (!args) {
+                await ctx.replaceMessage("Usage: /name <name>");
+                return true;
+            }
+            state.runner.renameSession(args);
+            await ctx.replaceMessage(`Session name set to: ${args}`);
+            return true;
+        case "/session":
+            await transport.showSessionCard(event, state.runner.getSessionCardData());
+            return true;
+        case "/tree":
+            if (!args) {
+                const browser = state.runner.getTreeBrowserData();
+                if (browser.entries.length === 0) {
+                    await ctx.replaceMessage("Session tree is empty.");
+                    return true;
+                }
+                let page = 0;
+                while (true) {
+                    const selected = await transport.promptTreeSelection(event, { ...browser, page });
+                    if (!selected || selected === "close") {
+                        await ctx.replaceMessage(state.runner.getTreeSummary());
+                        return true;
+                    }
+                    if (selected === "prev") {
+                        page = Math.max(0, page - 1);
+                        continue;
+                    }
+                    if (selected === "next") {
+                        page += 1;
+                        continue;
+                    }
+                    await ctx.replaceMessage(await state.runner.navigateTree(selected));
+                    return true;
+                }
+            }
+            await ctx.replaceMessage(await state.runner.navigateTree(args));
+            return true;
+        case "/model":
+            if (!args) {
+                let current = state.runner.currentModel();
+                const models = state.runner.listModels().split("\n").map((line) => line.replace(/^[*-]\s+/, "")).filter(Boolean);
+                let page = 0;
+                while (true) {
+                    const selected = await transport.promptModelSelection(event, {
+                        currentModel: current,
+                        models,
+                        title: "Select model",
+                        page,
+                    });
+                    if (!selected) {
+                        await ctx.replaceMessage(`Current model: ${current}`);
+                        return true;
+                    }
+                    if (selected === "prev") {
+                        page = Math.max(0, page - 1);
+                        continue;
+                    }
+                    if (selected === "next") {
+                        page += 1;
+                        continue;
+                    }
+                    if (selected === "close") {
+                        await ctx.replaceMessage(`Current model: ${current}`);
+                        return true;
+                    }
+                    try {
+                        current = await state.runner.setModel(selected);
+                        await ctx.replaceMessage(`Model set to ${current}`);
+                        return true;
+                    }
+                    catch (err) {
+                        await ctx.replaceMessage(err instanceof Error ? err.message : String(err));
+                        return true;
+                    }
+                }
+            }
+            try {
+                const selected = await state.runner.setModel(args);
+                await ctx.replaceMessage(`Model set to ${selected}`);
+            }
+            catch (err) {
+                await ctx.replaceMessage(err instanceof Error ? err.message : String(err));
+            }
+            return true;
+        case "/scoped-models":
+            if (!args) {
+                const available = state.runner.listModels().split("\n").map((line) => line.replace(/^[*-]\s+/, "")).filter(Boolean);
+                const current = state.runner.getScopedModels().split("\n").filter((line) => line.startsWith("- ")).map((line) => line.slice(2));
+                let page = 0;
+                while (true) {
+                    const selected = await transport.promptScopedModelSelection(event, { currentModels: current, models: available, page });
+                    if (selected === null || selected === "close") {
+                        await ctx.replaceMessage(state.runner.getScopedModels());
+                        return true;
+                    }
+                    if (selected === "prev") {
+                        page = Math.max(0, page - 1);
+                        continue;
+                    }
+                    if (selected === "next") {
+                        page += 1;
+                        continue;
+                    }
+                    await ctx.replaceMessage(selected.length > 0 ? state.runner.setScopedModels(selected.join(",")) : state.runner.clearScopedModels());
+                    return true;
+                }
+            }
+            if (args === "clear") {
+                await ctx.replaceMessage(state.runner.clearScopedModels());
+                return true;
+            }
+            await ctx.replaceMessage(state.runner.setScopedModels(args));
+            return true;
+        case "/settings": {
+            let summary = state.runner.getSettingsSummary();
+            while (true) {
+                const action = await transport.promptSettingsCard(event, summary);
+                if (!action || action === "done") {
+                    await ctx.replaceMessage(summary);
+                    return true;
+                }
+                summary = action === "thinking"
+                    ? state.runner.cycleThinkingSetting()
+                    : action === "transport"
+                        ? state.runner.cycleTransportSetting()
+                        : action === "steering"
+                            ? state.runner.toggleSteeringModeSetting()
+                            : action === "followup"
+                                ? state.runner.toggleFollowUpModeSetting()
+                                : state.runner.toggleAutoCompactSetting();
+            }
+        }
+        case "/compact": {
+            const approved = await transport.requestApproval(event, {
+                title: "Approve compaction",
+                description: args ? `Compact this session with custom instructions:\n\n${args}` : "Compact this session now?",
+                approveLabel: "Compact",
+                bullets: [
+                    "Summarizes older conversation history",
+                    "Keeps recent context and session continuity",
+                    "May lose some fine-grained older details",
+                ],
+                caution: "Compaction is lossy. Full history remains in the session file, but active context becomes summarized.",
+            });
+            if (!approved) {
+                await ctx.replaceMessage("Compaction cancelled.");
+                return true;
+            }
+            await ctx.replaceMessage(await state.runner.compact(args || undefined));
+            return true;
+        }
+        case "/reload": {
+            const approved = await transport.requestApproval(event, {
+                title: "Approve reload",
+                description: "Reload settings, skills, prompts, extensions, and model registry?",
+                approveLabel: "Reload",
+                bullets: [
+                    "Refreshes model registry and auth-backed availability",
+                    "Reloads skills, prompts, and extensions",
+                    "Applies updated configuration for future turns",
+                ],
+                caution: "Reload affects future turns. It does not rewrite past messages.",
+            });
+            if (!approved) {
+                await ctx.replaceMessage("Reload cancelled.");
+                return true;
+            }
+            await ctx.replaceMessage(await state.runner.reload());
+            return true;
+        }
+        case "/login":
+            await ctx.replaceMessage(args
+                ? `This Discord harness uses Pi's shared auth. Complete login locally with:\npi\n/login ${args}`
+                : "This Discord harness uses Pi's shared auth. Complete login locally with:\npi\n/login");
+            return true;
+        case "/logout":
+            await ctx.replaceMessage(args
+                ? `Log out locally with:\npi\n/logout ${args}`
+                : "Log out locally with:\npi\n/logout");
+            return true;
+        case "/stop":
+            await state.runner.abort();
+            await ctx.replaceMessage("Stop requested.");
+            return true;
+        case "/resume":
+        case "/fork":
+        case "/copy":
+        case "/export":
+        case "/share":
+        case "/hotkeys":
+        case "/changelog":
+        case "/quit":
+        case "/exit":
+            await ctx.replaceMessage(`${command} is a Pi TUI command that is not supported in this Discord harness.`);
+            return true;
+        default:
+            await ctx.replaceMessage(`Unknown command.\n\n${helpText()}`);
+            return true;
+    }
+}
+const handler = {
+    isRunning(conversationKey) {
+        return states.get(conversationKey)?.running ?? false;
+    },
+    async handleStop(conversationKey) {
+        const state = states.get(conversationKey);
+        if (!state?.running)
+            return;
+        state.stopRequested = true;
+        state.runner.abort();
+    },
+    async handleEvent(event, transport) {
+        if (await handleCommand(event, transport))
+            return;
+        const key = getConversationKey(event);
+        const state = getState(event);
+        if (state.running) {
+            const channel = await transport.createContext(event);
+            await channel.respond("Already working. Say `stop` to cancel.");
+            return;
+        }
+        state.running = true;
+        state.stopRequested = false;
+        log.info(`[${key}] starting run: ${event.text.slice(0, 80)}`);
+        try {
+            const ctx = await transport.createContext(event);
+            const result = await state.runner.run(ctx);
+            if (result.stopReason === "aborted" && state.stopRequested) {
+                await ctx.respondInThread("Stopped.");
+            }
+            else if (result.stopReason === "error" && result.errorMessage) {
+                await ctx.respondInThread(`Error: ${result.errorMessage}`);
+            }
+        }
+        catch (err) {
+            log.error(`[${key}] run failed`, err);
+        }
+        finally {
+            state.running = false;
+        }
+    },
+};
+const store = new ChannelStore(rootDir);
+bot = new DiscordBot(token, handler, store, rootDir);
+process.on("SIGINT", () => {
+    log.info("Shutting down...");
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    log.info("Shutting down...");
+    process.exit(0);
+});
+await bot.start();

package/dist/store.js

@@ -0,0 +1,60 @@
+import { appendFileSync, createWriteStream, mkdirSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import { dirname, extname, join } from "node:path";
+export class ChannelStore {
+    workingDir;
+    constructor(workingDir) {
+        this.workingDir = workingDir;
+    }
+    channelDir(channelId) {
+        return join(this.workingDir, channelId);
+    }
+    logPath(channelId) {
+        return join(this.channelDir(channelId), "log.jsonl");
+    }
+    contextPath(channelId) {
+        return join(this.channelDir(channelId), "context.jsonl");
+    }
+    attachmentsDir(channelId) {
+        return join(this.channelDir(channelId), "attachments");
+    }
+    ensureChannelDir(channelId) {
+        mkdirSync(this.channelDir(channelId), { recursive: true });
+    }
+    appendLog(channelId, entry) {
+        this.ensureChannelDir(channelId);
+        const path = this.logPath(channelId);
+        const line = `${JSON.stringify(entry)}\n`;
+        appendFileSync(path, line);
+    }
+    async storeAttachments(channelId, attachments) {
+        const dir = this.attachmentsDir(channelId);
+        mkdirSync(dir, { recursive: true });
+        const stored = [];
+        for (const attachment of attachments) {
+            const name = attachment.name ?? `${attachment.id}${extname(attachment.url)}`;
+            const localName = `${Date.now()}-${attachment.id}-${name}`;
+            const filePath = join(dir, localName);
+            const response = await fetch(attachment.url);
+            if (!response.ok)
+                continue;
+            await fs.mkdir(dirname(filePath), { recursive: true });
+            const fileStream = createWriteStream(filePath);
+            const buffer = Buffer.from(await response.arrayBuffer());
+            await new Promise((resolve, reject) => {
+                fileStream.on("finish", () => resolve());
+                fileStream.on("error", reject);
+                fileStream.end(buffer);
+            });
+            stored.push({
+                id: attachment.id,
+                url: attachment.url,
+                local: filePath,
+                name,
+                contentType: attachment.contentType,
+                size: attachment.size,
+            });
+        }
+        return stored;
+    }
+}

package/docs/github-release-flow.md

@@ -0,0 +1,237 @@
+# GitHub publish checklist and safe first release flow
+
+This guide is the exact recommended flow for publishing `pi-discord-bot` safely as a GitHub repository.
+
+---
+
+## Part 1: Pre-publish checklist
+
+Run these from the repo root:
+
+```bash
+cd ~/pi-discord-bot
+```
+
+### 1. Confirm runtime/private data is not being published
+Check that these are **not** intended for publication:
+- external workspace contents
+- local logs
+- local env files
+- auth files
+- downloaded attachments
+
+Quick check:
+
+```bash
+git status --ignored
+```
+
+You should see local env/runtime artifacts ignored, and the workspace should not live inside the repo.
+
+### 2. Confirm code is healthy
+
+```bash
+npm test
+npx tsc --noEmit
+```
+
+### 3. Review package metadata
+Open `package.json` and confirm:
+- `repository.url`
+- `homepage`
+- `bugs.url`
+- `bin`
+- `pi.skills`
+
+If you intend to publish to npm, also confirm the package name and version are correct.
+
+### 4. Confirm docs are publish-ready
+Check these files:
+- `README.md`
+- `docs/operator-env-config.md`
+- `docs/publishing-checklist.md`
+- `pi-discord-bot.env.example`
+- `discord-policy.example.json`
+- `pi-discord-bot.service`
+
+### 5. Confirm license choice
+This repo currently includes:
+- `LICENSE` = MIT
+
+If that is what you want, keep it.
+
+---
+
+## Part 2: Safe GitHub publish flow
+
+### Step 1: initialize git if needed
+
+```bash
+git init
+```
+
+### Step 2: inspect what will be committed
+
+```bash
+git status
+```
+
+Carefully verify that these are **not** staged or included:
+- workspace contents
+- `.env`
+- any private logs
+- any auth files
+
+### Step 3: stage files
+
+```bash
+git add .
+```
+
+### Step 4: inspect staged files before commit
+
+```bash
+git diff --cached --stat
+git diff --cached
+```
+
+This is the most important safety step.
+Do not skip it.
+
+### Step 5: first commit
+
+```bash
+git commit -m "Initial release"
+```
+
+### Step 6: create GitHub repo
+Create a new empty GitHub repository, for example:
+- `pi-discord-bot`
+
+Do **not** initialize it with:
+- README
+- license
+- gitignore
+
+because those already exist locally.
+
+### Step 7: connect remote
+
+```bash
+git branch -M main
+git remote add origin git@github.com:<YOUR_USER>/pi-discord-bot.git
+```
+
+Or use HTTPS:
+
+```bash
+git remote add origin https://github.com/<YOUR_USER>/pi-discord-bot.git
+```
+
+### Step 8: push
+
+```bash
+git push -u origin main
+```
+
+---
+
+## Part 3: Post-publish checks
+
+After pushing:
+
+### 1. Inspect the GitHub file list
+Make sure the repo does **not** contain:
+- `agent/`
+- local env files
+- logs
+- private artifacts
+
+### 2. Check rendered docs
+Verify on GitHub that these render well:
+- `README.md`
+- `docs/operator-env-config.md`
+- `docs/publishing-checklist.md`
+- `docs/github-release-flow.md`
+
+### 3. Check example files
+Make sure users can easily find:
+- `pi-discord-bot.env.example`
+- `discord-policy.example.json`
+- `pi-discord-bot.service`
+
+---
+
+## Part 4: Recommended first public release posture
+
+For the public release, I recommend:
+- publish the GitHub repo
+- publish the npm package
+- support both Pi package install and source checkout workflows
+
+That gives users a simple low-friction install path while still keeping the source repo available.
+
+---
+
+## Part 5: Optional GitHub release tag flow
+
+After the initial repo push, if you want a tagged release:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+Then create a GitHub Release in the UI.
+
+Suggested first release title:
+- `v0.1.0 — Initial public release`
+
+Suggested notes:
+- Discord harness around Pi primitives
+- Discord-native model/settings/tree/approval cards
+- systemd-friendly local operation
+- Pi shared auth/settings flow
+- runtime workspace stored outside the repo by default
+
+---
+
+## Part 6: Safe npm publish flow
+
+When ready:
+1. confirm package metadata and version
+2. run:
+
+```bash
+npm pack --dry-run
+```
+
+3. inspect included files carefully
+4. publish:
+
+```bash
+npm publish --access public
+```
+
+---
+
+## Short version
+
+If you want the shortest safe release path:
+
+```bash
+cd ~/pi-discord-bot
+npm test
+npx tsc --noEmit
+git init
+git add .
+git diff --cached --stat
+git commit -m "Initial release"
+git branch -M main
+git remote add origin git@github.com:<YOUR_USER>/pi-discord-bot.git
+git push -u origin main
+npm pack --dry-run
+npm publish --access public
+```
+
+Before `git commit`, verify again that workspace data is **not** included.