@staix/agent-hub 0.12.23 → 0.12.25

package/src/pet/config.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { characterId, type CharacterId, type PetSize, type PetGlyphs } from "./frame.ts";
+
+export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; notice?: string }
+/** Console-local presentation only; this reader never writes config or grants authority. */
+export function loadPetConfig(cwd: string): PetConfig {
+  let value: unknown;
+  for (const name of ["config.json", "config.local.json"]) {
+    try {
+      const file = JSON.parse(readFileSync(join(cwd, ".agenthub", name), "utf8"));
+      if (file.pet !== undefined) value = value && typeof value === "object" && file.pet && typeof file.pet === "object" ? { ...value, ...file.pet } : file.pet;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+  if (value === false) return { enabled: false, blink: true, bell: false };
+  const defaults = { enabled: true, blink: true, bell: false };
+  if (value === undefined) return defaults;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: "Unknown pet configuration; using stai line defaults." };
+  const row = value as Record<string, unknown>;
+  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell"].includes(key)) ||
+    row.character !== undefined && !characterId(row.character) || row.size !== undefined && !["line", "mini", "full"].includes(row.size as string) ||
+    row.glyphs !== undefined && (typeof row.glyphs !== "string" || !["auto", "ascii", "blocks"].includes(row.glyphs)) ||
+    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean";
+  return { enabled: true, blink: typeof row.blink === "boolean" ? row.blink : true, bell: typeof row.bell === "boolean" ? row.bell : false,
+    ...(characterId(row.character) && row.character !== "stai" ? { character: row.character } : {}),
+    ...(row.size === "mini" || row.size === "full" ? { size: row.size } : {}),
+    ...(row.glyphs === "ascii" || row.glyphs === "blocks" ? { glyphs: row.glyphs } : {}),
+    ...(invalid ? { notice: "Unknown pet option; using stai line defaults for that option." } : {}) };
+}

package/src/pet/frame.ts

@@ -0,0 +1,17 @@
+import { CHARACTERS, CHARACTER_IDS, type CharacterId, type PetGlyphs, type PetPose, type PetSize } from "./characters.ts";
+export { CHARACTERS, CHARACTER_IDS };
+export type { CharacterId, PetGlyphs, PetPose, PetSize };
+export function characterId(value: unknown): value is CharacterId { return typeof value === "string" && (CHARACTER_IDS as readonly string[]).includes(value); }
+export function petSize(requested: PetSize = "line", columns: number, rows: number): PetSize {
+  if (requested === "full" && columns >= 100 && rows >= 40) return "full";
+  return requested !== "line" && columns >= 100 ? "mini" : "line";
+}
+export function petGlyphs(requested: PetGlyphs = "auto", env: Record<string, string | undefined> = process.env): "ascii" | "blocks" {
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
+  return requested !== "ascii" && /utf-?8/i.test(locale) && !!env.TERM && !["dumb", "linux"].includes(env.TERM) ? "blocks" : "ascii";
+}
+export function petFrame(character: CharacterId = "stai", pose: PetPose, size: PetSize = "line", glyphs: "ascii" | "blocks" = "ascii"): readonly string[] {
+  return CHARACTERS[character].frames[glyphs][pose][size];
+}
+/** A full footer reserves the catalog maximum, independent of state and session character cycling. */
+export function petFooterRows(size: PetSize): number { return size === "full" ? 9 : 4; }

package/src/pet/pixels.ts

@@ -0,0 +1,28 @@
+/** Self-contained glyph pixels for the shared literal frame data; browser injection needs no font/image decoder. */
+export function petPixels(frame: readonly string[]): { width: number; height: number; pixels: [number, number][] } {
+  const font: Record<string, string[]> = {
+    O:["01110","10001","10001","10001","10001","10001","01110"],
+    o:["00000","00000","01110","10001","10001","01110","00000"],
+    X:["10001","10001","01010","00100","01010","10001","10001"],
+    S:["01111","10000","10000","01110","00001","00001","11110"],
+    T:["11111","00100","00100","00100","00100","00100","00100"],
+    A:["01110","10001","10001","11111","10001","10001","10001"],
+    I:["11111","00100","00100","00100","00100","00100","11111"],
+    ">": ["10000","01000","00100","00010","00100","01000","10000"],
+    "<": ["00001","00010","00100","01000","00100","00010","00001"],
+    "^": ["00100","01010","10001"],
+    "~": ["00000","01001","10110"],
+    "/": ["00001","00001","00010","00100","01000","10000","10000"],
+    "\\": ["10000","10000","01000","00100","00010","00001","00001"],
+    "-": ["00000","00000","00000","11111"],
+    "'": ["00100","00100"],
+  };
+  const pixels: [number, number][] = [];
+  for (const [row, text] of frame.entries()) for (const [column, glyph] of [...text].entries()) {
+    for (let y=0;y<8;y++) for (let x=0;x<5;x++) {
+      const on = glyph === "█" || glyph === "▀" && y<4 || glyph === "▄" && y>=4 || glyph === "▟" && (y>=4 || x>=2) || glyph === "▙" && (y>=4 || x<3) || font[glyph]?.[y]?.[x] === "1";
+      if (on) pixels.push([column*5+x,row*8+y]);
+    }
+  }
+  return { width: Math.max(0,...frame.map(row=>[...row].length))*5, height: frame.length*8, pixels };
+}

package/src/pi/extension.ts

@@ -23,6 +23,9 @@ let shellSeq = 0;
 let forcedFailure = "";
 let turnGeneration = 0;
 let sessionId = "";
+let pendingPromptId: string | undefined;
+let activePromptId: string | undefined;
+let settlement: Promise<void> | undefined;
 const maxSteps = Number(process.env.AGENTHUB_PI_MAX_STEPS ?? 30);
 let shutdown: (() => void) | undefined;
 let runtimeCtx: any;
@@ -66,7 +69,30 @@ async function poll(pi: ExtensionAPI): Promise<void> {
       if (!command) continue;
       try {
         if (command.type === "prompt" || command.type === "steer") {
+          if (command.type === "prompt") {
+            // Let our settled callback return to native Pi before the normal queued successor starts.
+            if (settlement) {
+              let timer: ReturnType<typeof setTimeout> | undefined;
+              try { await Promise.race([settlement, new Promise<void>(resolve => { timer = setTimeout(resolve, 5_000); })]); }
+              finally { clearTimeout(timer); }
+            }
+            if (settlement || runtimeCtx?.isIdle?.() !== true || (command.sessionId !== undefined && command.sessionId !== sessionId) || (command.generation !== undefined && command.generation !== turnGeneration)) {
+              await post("/ack", { id: command.id, ok: false, error: "Pi prompt was not inserted because its native session is no longer idle at the expected generation", refusal: { kind: "prompt_not_started", promptId: command.id, sessionId, generation: turnGeneration } });
+              continue;
+            }
+            // Pinned Pi 1.0.1 starts _runAgentPrompt synchronously before its first await.
+            // Keep this check and insertion in one JS turn; snapshots cannot reserve native idleness.
+            pendingPromptId = command.id;
+          }
           pi.sendMessage({ customType: "agent-hub", content: String(command.message ?? ""), display: true }, { triggerTurn: command.type === "prompt", deliverAs: command.type === "steer" ? "steer" : "followUp" });
+          if (command.type === "prompt" && runtimeCtx?.isIdle?.() !== false) {
+            // Another extension's async settled hook can make native Pi defer this insertion.
+            // Our callback barrier is not an atomic native reservation: keep that effect uncertain.
+            if (pendingPromptId === command.id) pendingPromptId = undefined;
+            if (activePromptId === command.id) activePromptId = undefined;
+            await post("/ack", { id: command.id, ok: false, error: "Pi prompt insertion did not synchronously claim a native turn", refusal: { kind: "prompt_uncertain", promptId: command.id, sessionId, generation: turnGeneration } });
+            continue;
+          }
         } else if (command.type === "get_session_state") {
           const entries = runtimeCtx.sessionManager.getEntries();
           await post("/ack", { id: command.id, ok: true, result: {
@@ -94,7 +120,7 @@ async function poll(pi: ExtensionAPI): Promise<void> {
           }
         }
         await post("/ack", { id: command.id, ok: true });
-      } catch (error) { await post("/ack", { id: command.id, ok: false, error: (error as Error).message }); }
+      } catch (error) { if (pendingPromptId === command.id) pendingPromptId = undefined; await post("/ack", { id: command.id, ok: false, error: (error as Error).message }); }
     } catch { await new Promise((resolve) => setTimeout(resolve, 250)); }
   }
 }
@@ -117,7 +143,7 @@ export default function(pi: ExtensionAPI): void {
     const state = ctx.sessionManager.getHeader();
     sessionId = String(state?.id ?? "");
     try {
-      const claimed = await post("/event", { type: "session_start", ownerToken, pid: process.pid, signature: processSignature(process.pid), sessionId: state?.id, sessionFile: ctx.sessionManager.getSessionFile(), approvalTurnAbort: typeof ctx.abort === "function" });
+      const claimed = await post("/event", { type: "session_start", ownerToken, pid: process.pid, signature: processSignature(process.pid), sessionId: state?.id, sessionFile: ctx.sessionManager.getSessionFile(), approvalTurnAbort: typeof ctx.abort === "function", fencedPrompt: true });
       if (claimed?.ok === false) { ctx.shutdown?.(); return; }
     } catch (error) { ctx.shutdown?.(); throw error; }
     if (!pollStarted) { pollStarted = true; void poll(pi); }
@@ -127,7 +153,7 @@ export default function(pi: ExtensionAPI): void {
     const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
     const failed = !!forcedFailure || message?.stopReason === "error";
     const cancelled = !forcedFailure && message?.stopReason === "aborted";
-    await post("/event", { type: "agent_end", generation: turnGeneration, text: text ?? "", failed, cancelled, ...(failed ? { error: forcedFailure || message?.errorMessage || message?.stopReason } : {}) });
+    await post("/event", { type: "agent_end", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}), text: text ?? "", failed, cancelled, ...(failed ? { error: forcedFailure || message?.errorMessage || message?.stopReason } : {}) });
   });
   pi.on("message_end", async (event: any) => {
     const tokens = assistantTokens(event.message);
@@ -142,7 +168,8 @@ export default function(pi: ExtensionAPI): void {
     lastActivity = now;
     try { await post("/event", { type: "activity" }); } catch { /* shutdown owns bridge cleanup */ }
   });
-  pi.on("agent_start", async () => { toolSteps = 0; forcedFailure = ""; turnGeneration++; await post("/event", { type: "agent_start", generation: turnGeneration }); });
+  // Native retries/continuations emit more starts before the one logical agent_settled.
+  pi.on("agent_start", async () => { toolSteps = 0; forcedFailure = ""; turnGeneration++; activePromptId = pendingPromptId ?? activePromptId; pendingPromptId = undefined; await post("/event", { type: "agent_start", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}) }); });
   pi.on("model_select", async (_event: any, ctx: any) => { if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") ctx.shutdown?.(); });
   pi.on("before_agent_start", async (event: any, ctx: any) => {
     if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") { ctx.abort?.(); return { systemPrompt: event.systemPrompt }; }
@@ -157,10 +184,18 @@ export default function(pi: ExtensionAPI): void {
     return undefined;
   });
   pi.on("agent_settled", async (_event: any, ctx: any) => {
+    let release!: () => void;
+    const current = new Promise<void>(resolve => { release = resolve; });
+    settlement = current;
     const entries = ctx.sessionManager?.getEntries?.() ?? [];
     const message = entries.slice().reverse().find((entry: any) => entry.type === "message" && entry.message?.role === "assistant")?.message;
     const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
-    await post("/event", { type: "agent_settled", generation: turnGeneration, ...(text ? { text } : {}) });
+    try { await post("/event", { type: "agent_settled", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}), ...(text ? { text } : {}) }); }
+    finally {
+      activePromptId = undefined;
+      // Release after this callback returns, not inside its awaited POST continuation.
+      setTimeout(() => { if (settlement === current) settlement = undefined; release(); }, 0);
+    }
   });
   pi.on("user_bash", async (event: any) => {
     const generation = turnGeneration, callSessionId = sessionId;

package/src/role-text.d.ts

@@ -0,0 +1 @@
+declare module "*.md" { const text: string; export default text; }