@h-rig/pi-rig 0.0.6-alpha.9 → 0.0.6-alpha.90

package/dist/src/commands.js

@@ -1,5 +1,13 @@
 // @bun
 // packages/pi-rig/src/commands.ts
+function runRecordFromPayload(payload) {
+  return payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
+}
+function formatEntry(entry) {
+  const type = String(entry.type ?? entry.title ?? "event");
+  const text = typeof entry.text === "string" ? entry.text : typeof entry.detail === "string" ? entry.detail : typeof entry.message === "string" ? entry.message : JSON.stringify(entry);
+  return `${type}: ${text}`;
+}
 function createRigSlashCommands(input) {
   const notify = input.notify ?? (() => {});
   async function handleRig(args) {
@@ -28,18 +36,55 @@ function createRigSlashCommands(input) {
       }
       if (first === "attach") {
         const run = await input.client.attach(second);
-        const runRecord = run.run && typeof run.run === "object" ? run.run : run;
+        const runRecord = runRecordFromPayload(run);
         notify(`Attached to ${String(runRecord.runId ?? second ?? input.context.runId ?? "run")}: ${String(runRecord.status ?? "unknown")}`, "info");
         return;
       }
-      notify("Usage: /rig status | /rig task list | /rig task run [id] | /rig attach [run-id]", "error");
+      if (first === "timeline" || first === "logs") {
+        const runId = second || input.context.runId;
+        const entries = first === "timeline" ? await input.client.runTimeline(runId, 20) : await input.client.runLogs(runId, 20);
+        notify(entries.length > 0 ? entries.slice(-10).map(formatEntry).join(`
+`) : `No ${first} entries for ${runId ?? "run"}.`, "info");
+        return;
+      }
+      if (first === "steer") {
+        const message = args.trim().slice("steer".length).trim();
+        if (!message) {
+          notify("Usage: /rig steer <message>", "error");
+          return;
+        }
+        await input.client.steer(message);
+        notify("Rig steering message queued.", "info");
+        return;
+      }
+      if (first === "stop") {
+        await input.client.stop(second || input.context.runId);
+        notify("Rig stop requested.", "info");
+        return;
+      }
+      if (first === "abort") {
+        await input.client.workerAbort(second || input.context.runId);
+        notify("Worker turn abort requested.", "info");
+        return;
+      }
+      if (first === "sh") {
+        const command = args.trim().slice("sh".length).trim();
+        if (!command) {
+          notify("Usage: /rig sh <command> \u2014 runs in the WORKER workspace", "error");
+          return;
+        }
+        await input.client.workerShell(command, input.context.runId);
+        notify("Shell command sent to the worker workspace.", "info");
+        return;
+      }
+      notify("Usage: /rig status | /rig task list | /rig task run [id] | /rig attach [run-id] | /rig timeline [run-id] | /rig logs [run-id] | /rig steer <message> | /rig stop [run-id] | /rig abort [run-id] | /rig sh <command>", "error");
     } catch (error) {
       notify(error instanceof Error ? error.message : String(error), "error");
     }
   }
   return {
     rig: {
-      description: "Rig control-plane commands: status, task list, task run, attach",
+      description: "Rig control-plane commands: status, task list, task run, attach, timeline, logs, steer, stop",
       handler: handleRig
     }
   };

package/dist/src/index.d.ts

@@ -0,0 +1,59 @@
+import { RigBridgeClient, type RigExtensionContext, type RigProtocolCheck, type RigWebSocketFactory } from "./client";
+export type MinimalPiApi = {
+    registerCommand?: (name: string, command: {
+        description?: string;
+        handler: (args: string, ctx: unknown) => Promise<void>;
+    }) => void;
+    registerTool?: (tool: {
+        name: string;
+    } & Record<string, unknown>) => void;
+    on?: (eventName: string, handler: (event: unknown, ctx: unknown) => unknown) => void;
+    sendUserMessage?: (content: string, options?: {
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+        triggerTurn?: boolean;
+    }) => void | Promise<void>;
+    /** Stock Pi custom-message injection: rendered in the transcript without
+     * triggering a turn. The operator console's live worker mirror rides this. */
+    sendMessage?: (message: {
+        customType: string;
+        content: string;
+        display?: boolean;
+        details?: unknown;
+    }, options?: {
+        triggerTurn?: boolean;
+    }) => void | Promise<void>;
+    /** Stock custom-message renderer registration: the live mirror renders
+     * worker turns through Pi's own components via this seam. */
+    registerMessageRenderer?: (customType: string, renderer: (message: unknown, options: {
+        expanded: boolean;
+    }, theme: unknown) => unknown) => void;
+};
+export type PiRigExtensionState = RigExtensionContext & {
+    readonly client: RigBridgeClient;
+    /** Test seam: lets the suite fake the push socket. Defaults to the global WebSocket. */
+    readonly webSocketFactory?: RigWebSocketFactory;
+};
+export declare function createPiRigExtensionState(input?: {
+    readonly env?: Record<string, string | undefined>;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: RigWebSocketFactory;
+}): PiRigExtensionState;
+export type PiRigBridgeGate = {
+    readonly allowed: boolean;
+    readonly message: string | null;
+    /** Handshake outcome: "compatible" means the server speaks this protocol
+     * version and therefore supports the WS push surface. */
+    readonly status: RigProtocolCheck["status"];
+};
+export type PiRigBridgeGateCheck = (ctx: unknown) => Promise<PiRigBridgeGate>;
+/** Live refresh control handed to the operator widget by the WS bridge:
+ * while the socket is up, pushes (rig.event / snapshotInvalidated) drive the
+ * widget instead of the 1s status poll. */
+export type OperatorLiveRefresh = {
+    isConnected(): boolean;
+    /** Returns true (and resets) when a push arrived since the last check. */
+    consumePushTrigger(): boolean;
+};
+export default function createPiRigExtension(pi: MinimalPiApi, options?: {
+    state?: PiRigExtensionState;
+}): void;