@astrofoundry/pi-astro 0.23.0 → 0.23.1

package/extensions/astro-discord/commands.ts

@@ -48,12 +48,15 @@ export const CHANNEL_RULES = `## Channel rules
 
 This task arrived from a Discord channel and your answer is posted there. Answer in plain text under 1500 characters when possible, facts first, no headings. When the task is ambiguous (which guest, which record, which host), do not act: ask one precise question and stop. Risky calls may wait for an operator's approval; if the tool reports a denial or a missing answer, report it and stop.`;
 
-export function helpText(allowed: readonly string[], present: readonly string[], isOwner: boolean, trigger: Trigger): string {
+export function helpText(allowed: readonly string[], present: readonly string[], isOwner: boolean, trigger: Trigger, canConfig: boolean): string {
     if (allowed.length === 0) return present.length === 0 ? "No specialist is present in this channel." : "You may not use the specialists present in this channel.";
     const how = present.length === 1 ? `Every message${trigger === "mention" ? " that addresses me" : ""} here goes to \`${present[0]}\`.` : `Send \`<specialist> <task>\`${trigger === "mention" ? " after mentioning me" : ""}. Specialists you may use here:`;
     const lines = [how];
     if (present.length > 1) lines.push(...allowed.map((name) => `• \`${name}\``));
-    lines.push("Reactions: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed. `status` lists running tasks.");
+    lines.push("Reactions: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed.");
+    const commands = ["`help` this message", "`status` running tasks"];
+    if (canConfig) commands.push("`config show`", "`config channel <#channel> <always|mention> <*|name,name>`", "`config access <specialist> add|remove <@user>`");
+    lines.push(`Commands: ${commands.join(", ")}.`);
     if (isOwner) lines.push("Owners approve risky calls with the buttons the bot posts and may use every specialist.");
     return lines.join("\n");
 }

package/extensions/astro-discord/discord.test.ts

@@ -118,10 +118,12 @@ describe("commands", () => {
     });
 
     it("writes help and prefix texts", () => {
-        expect(helpText([], [], false, "always")).toMatch(/No specialist/);
-        expect(helpText([], ["dns"], false, "always")).toMatch(/may not/);
-        expect(helpText(["arcane"], ["arcane"], false, "mention")).toMatch(/addresses me here goes to `arcane`/);
-        expect(helpText(["dns"], ["dns", "edge"], true, "always")).toMatch(/`dns`/);
+        expect(helpText([], [], false, "always", false)).toMatch(/No specialist/);
+        expect(helpText([], ["dns"], false, "always", false)).toMatch(/may not/);
+        expect(helpText(["arcane"], ["arcane"], false, "mention", false)).toMatch(/addresses me here goes to `arcane`/);
+        expect(helpText(["dns"], ["dns", "edge"], true, "always", false)).toMatch(/`dns`/);
+        expect(helpText(["dns"], ["dns"], true, "always", false)).not.toMatch(/config show/);
+        expect(helpText(["dns"], ["dns"], true, "always", true)).toMatch(/`config show`/);
         expect(needsPrefixText(["dns", "edge"])).toMatch(/`dns`, `edge`/);
     });
 });

package/extensions/astro-discord/index.ts

@@ -205,7 +205,7 @@ class Bridge {
         }
         if (allowed.length === 0) return;
         if (command.kind === "help") {
-            await this.rest.createMessage(message.channel_id, { content: helpText(allowed, present, owner, channel.settings.trigger), replyTo: message.id });
+            await this.rest.createMessage(message.channel_id, { content: helpText(allowed, present, owner, channel.settings.trigger, owner && channel.id === this.config.adminChannelId), replyTo: message.id });
             return;
         }
         if (command.kind === "status") {
@@ -230,6 +230,14 @@ class Bridge {
         task.startedAt = Date.now();
         this.active.set(task.specialist, task);
         await this.rest.addReaction(task.channelId, task.messageId, REACTION.running);
+        const placeholder = await this.rest
+            .createMessage(task.channelId, { content: `${REACTION.running} **${task.specialist}** is working on your task, please wait…`, replyTo: task.messageId })
+            .then((m) => m.id)
+            .catch(() => undefined);
+        // Discord clears the typing indicator after about ten seconds; refresh it while the task runs.
+        await this.rest.triggerTyping(task.channelId).catch(() => undefined);
+        const typing = setInterval(() => void this.rest.triggerTyping(task.channelId).catch(() => undefined), 8000);
+        typing.unref();
         log(`run astro.${task.specialist} for ${task.userId}: ${taskText.slice(0, 200)}`);
         const dirs = defaultDirs();
         const { skills, missing } = resolveSkills(agent.skills, dirs);
@@ -273,26 +281,30 @@ class Bridge {
         } catch (err) {
             output = err instanceof Error ? err.message : String(err);
         } finally {
+            clearInterval(typing);
             this.active.delete(task.specialist);
         }
         await this.rest.removeOwnReaction(task.channelId, task.messageId, REACTION.running).catch(() => undefined);
         await this.rest.addReaction(task.channelId, task.messageId, failed ? REACTION.failed : REACTION.done).catch(() => undefined);
-        await this.post(task, `${failed ? "❌" : "✅"} **${task.specialist}**\n${output}`, attachment);
+        await this.deliver(task, placeholder, `${failed ? "❌" : "✅"} **${task.specialist}**\n${output}`, attachment);
     }
 
-    private async post(task: ActiveTask, text: string, attachment?: string): Promise<void> {
-        if (attachment !== undefined) {
-            await this.rest.createMessage(task.channelId, { content: text.slice(0, 1900), replyTo: task.messageId, file: { name: `astro-${task.specialist}-stderr-${Date.now()}.txt`, content: attachment } });
-            return;
-        }
-        if (text.length > ATTACHMENT_THRESHOLD) {
-            const summary = `${text.slice(0, 1200).trim()}\n… full answer attached (${text.length} characters).`;
-            await this.rest.createMessage(task.channelId, { content: summary, replyTo: task.messageId, file: { name: `astro-${task.specialist}-${Date.now()}.md`, content: text } });
+    /** Turns the "working" placeholder into the answer: edit it in place when it fits, otherwise replace it with chunks or an attachment. */
+    private async deliver(task: ActiveTask, placeholder: string | undefined, text: string, attachment?: string): Promise<void> {
+        const oversized = attachment !== undefined || text.length > ATTACHMENT_THRESHOLD;
+        if (oversized) {
+            if (placeholder) await this.rest.deleteMessage(task.channelId, placeholder).catch(() => undefined);
+            const file = attachment !== undefined ? { name: `astro-${task.specialist}-stderr-${Date.now()}.txt`, content: attachment } : { name: `astro-${task.specialist}-${Date.now()}.md`, content: text };
+            const content = attachment !== undefined ? text.slice(0, 1900) : `${text.slice(0, 1200).trim()}\n… full answer attached (${text.length} characters).`;
+            await this.rest.createMessage(task.channelId, { content, replyTo: task.messageId, file });
             return;
         }
         const chunks = chunkMessage(text);
-        for (let i = 0; i < chunks.length; i++) {
-            await this.rest.createMessage(task.channelId, { content: chunks[i], replyTo: i === 0 ? task.messageId : undefined });
+        if (chunks.length === 0) chunks.push(text);
+        if (placeholder) await this.rest.editMessage(task.channelId, placeholder, chunks[0]).catch(() => undefined);
+        else await this.rest.createMessage(task.channelId, { content: chunks[0], replyTo: task.messageId });
+        for (let i = 1; i < chunks.length; i++) {
+            await this.rest.createMessage(task.channelId, { content: chunks[i] });
         }
     }
 

package/extensions/astro-discord/rest.ts

@@ -72,6 +72,15 @@ export class DiscordRest {
         await this.call("PATCH", `/channels/${channelId}/messages/${messageId}`, JSON.stringify({ content, components, allowed_mentions: { parse: [] } }), "application/json");
     }
 
+    /** Shows the "Cortex is typing…" indicator for about ten seconds. */
+    async triggerTyping(channelId: string): Promise<void> {
+        await this.call("POST", `/channels/${channelId}/typing`);
+    }
+
+    async deleteMessage(channelId: string, messageId: string): Promise<void> {
+        await this.call("DELETE", `/channels/${channelId}/messages/${messageId}`);
+    }
+
     async addReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
         await this.call("PUT", `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "description": "Personal pi customizations (extensions, subagents, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"

package/specialists/lib/pinned.ts

@@ -25,7 +25,8 @@ export function pinnedRequest(url: URL, options: PinnedOptions): Promise<PinnedR
     return new Promise((resolve, reject) => {
         const req = httpsRequest(
             url,
-            { method: options.method, rejectUnauthorized: false, headers: options.headers, timeout: options.timeoutMs },
+            // agent:false forces a new connection per call: a pooled TLS socket returns an empty peer certificate on reuse, which would fail the pin.
+            { method: options.method, rejectUnauthorized: false, headers: options.headers, timeout: options.timeoutMs, agent: false },
             (res) => {
                 const socket = res.socket as { getPeerCertificate?: () => { fingerprint256?: string } };
                 const fingerprint = socket.getPeerCertificate?.().fingerprint256 ?? "";