@polderlabs/bizar 5.4.0 → 5.5.0

package/plugins/bizar/src/tools/bg-report-progress.ts

@@ -0,0 +1,101 @@
+/**
+ * plugins/bizar/src/tools/bg-report-progress.ts
+ *
+ * v5.x — `bizar_report_progress` tool. Lets a running background agent
+ * push a structured progress update (step/total/message) into the
+ * instance state. The dashboard reads `progress` and renders a
+ * progress bar; `progressMessage` shows the free-form status line.
+ *
+ * Available to ALL agents (the body of a bg agent calls it; not just
+ * Odin). The `bizar_*` prefix is reserved; the auth filter is "all",
+ * matching the "tools all agents can call" pattern of
+ * `bizar_status`.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+import type { InstanceManager } from "../background.js";
+import type { Logger } from "../logger.js";
+
+export interface BgReportProgressDeps {
+  instanceManager: InstanceManager;
+  logger: Logger;
+}
+
+export function createBgReportProgressTool(deps: BgReportProgressDeps) {
+  return tool({
+    description:
+      "Report progress on the current background instance. " +
+      "Available to all agents. step/total are integers; message is a " +
+      "free-form status hint shown next to the progress bar.",
+    args: {
+      instanceId: z
+        .string()
+        .min(1)
+        .describe("Instance id (the one returned by bizar_spawn_background)."),
+      step: z
+        .number()
+        .int()
+        .min(0)
+        .describe("Current step (>=0)."),
+      total: z
+        .number()
+        .int()
+        .positive()
+        .describe("Total step count (>0)."),
+      message: z
+        .string()
+        .optional()
+        .describe("Optional human-readable status."),
+      indeterminate: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Set true to show an indeterminate (unknown) progress."),
+    },
+    execute: async (rawArgs) => {
+      const args = rawArgs as {
+        instanceId: string;
+        step: number;
+        total: number;
+        message?: string;
+        indeterminate?: boolean;
+      };
+      try {
+        const result = await deps.instanceManager.updateProgress(
+          args.instanceId,
+          args.step,
+          args.total,
+          args.message,
+          Boolean(args.indeterminate),
+        );
+        if (!result.ok) {
+          return {
+            output: JSON.stringify({
+              error: result.error || "progress_failed",
+              instanceId: args.instanceId,
+            }),
+          };
+        }
+        return {
+          output: JSON.stringify({
+            instanceId: args.instanceId,
+            progress: result.progress,
+          }),
+        };
+      } catch (err: unknown) {
+        deps.logger.warn(
+          `bizar: report-progress(${args.instanceId}) threw: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+        return {
+          output: JSON.stringify({
+            error: `report-progress threw: ${err instanceof Error ? err.message : String(err)}`,
+            instanceId: args.instanceId,
+          }),
+        };
+      }
+    },
+  });
+}

package/plugins/bizar/src/tools/bg-resume.ts

@@ -0,0 +1,72 @@
+/**
+ * plugins/bizar/src/tools/bg-resume.ts
+ *
+ * v5.x — `bizar_resume` tool. Sends SIGCONT to a paused background
+ * agent's subprocess. Companion to {@link ./bg-pause.ts}.
+ *
+ * Odin-only.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+import type { InstanceManager } from "../background.js";
+import type { Logger } from "../logger.js";
+
+export interface BgResumeDeps {
+  instanceManager: InstanceManager;
+  logger: Logger;
+}
+
+export function createBgResumeTool(deps: BgResumeDeps) {
+  return tool({
+    description:
+      "Resume a paused background agent by sending SIGCONT to its subprocess. " +
+      "Only Odin may resume. No-op on already-running instances. POSIX only.",
+    args: {
+      instanceId: z
+        .string()
+        .min(1)
+        .describe("Instance id returned by bizar_spawn_background."),
+    },
+    execute: async (rawArgs, ctx) => {
+      if (ctx.agent !== "odin") {
+        return {
+          output: JSON.stringify({
+            error:
+              "Only Odin can resume background agents. Use bizar_status to inspect or ask Odin to resume.",
+          }),
+        };
+      }
+      const args = rawArgs as { instanceId: string };
+      try {
+        const result = await deps.instanceManager.resume(args.instanceId);
+        if (!result.ok) {
+          return {
+            output: JSON.stringify({
+              error: result.error || "resume failed",
+              instanceId: args.instanceId,
+            }),
+          };
+        }
+        return {
+          output: JSON.stringify({
+            instanceId: args.instanceId,
+            status: "running",
+          }),
+        };
+      } catch (err: unknown) {
+        deps.logger.warn(
+          `bizar: resume(${args.instanceId}) threw: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+        return {
+          output: JSON.stringify({
+            error: `resume threw: ${err instanceof Error ? err.message : String(err)}`,
+            instanceId: args.instanceId,
+          }),
+        };
+      }
+    },
+  });
+}

package/plugins/bizar/src/tools/bg-send-message.ts

@@ -0,0 +1,105 @@
+/**
+ * plugins/bizar/src/tools/bg-send-message.ts
+ *
+ * v5.x — `bizar_send_message` tool. Mid-flight redirect for a
+ * background agent — "steer" the running instance with a new
+ * instruction.
+ *
+ * ────────────────────────────────────────────────────────────────
+ * v0.8.0 DESIGN NOTE — why this tool is a structured no-op
+ * ────────────────────────────────────────────────────────────────
+ * In the opencode 1.17 `serve` HTTP API (used by bg-spawn up to v0.7)
+ * you could `POST /session/{id}/prompt` to send a follow-up message
+ * to a running session — the loop would pick it up mid-run and start
+ * a new turn. That's the "real" steer path.
+ *
+ * In v0.8.0 the plugin switched to `opencode run`, which is a
+ * one-shot CLI: it accepts the prompt on the command line, runs the
+ * agent loop to completion, and exits. There is no documented HTTP /
+ * IPC channel for sending a follow-up user message mid-run. The
+ * subprocess doesn't expose one and we don't own the opencode source.
+ *
+ * Two paths to a workable steer:
+ *
+ *   1. **Switch back to HTTP server mode** — every bg agent would
+ *      start its own `opencode serve` + a server-side streaming
+ *      prompt. Heavyweight (extra processes, double the memory) and
+ *      a 1-2 sprint piece of work.
+ *
+ *   2. **Kill + restart with appended prompt** — graceful shutdown
+ *      of the current subprocess, spin up a new one whose prompt is
+ *      `(original) + "\n\n[STEERED " + ISO timestamp + "]\n" + msg`.
+ *      Cheaper; matches the user's mental model of "send new
+ *      instruction"; implemented in the dashboard at
+ *      `POST /api/background/:id/steer`.
+ *
+ * We document the constraint here. The tool itself returns the
+ * concrete error and the recommended path so the agent can either
+ * (a) ask Odin to use the dashboard steer endpoint or (b) call
+ * `bizar_kill` + `bizar_spawn_background` with a combined prompt as
+ * a backup.
+ *
+ * In a future v0.9.x this tool will be promoted to the real
+ * implementation once opencode run supports mid-flight prompting.
+ */
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+import type { InstanceManager } from "../background.js";
+import type { Logger } from "../logger.js";
+
+export interface BgSendMessageDeps {
+  instanceManager: InstanceManager;
+  logger: Logger;
+}
+
+export function createBgSendMessageTool(deps: BgSendMessageDeps) {
+  return tool({
+    description:
+      "Send a follow-up message to a running background agent. " +
+      "v0.8.0 LIMITATION: opencode run is a one-shot CLI and does not " +
+      "support mid-flight prompting. This tool returns an `unavailable_in_subprocess_mode` " +
+      "error and points the caller to the dashboard's steer endpoint, " +
+      "which performs kill+restart-with-appended-prompt.",
+    args: {
+      instanceId: z
+        .string()
+        .min(1)
+        .describe("Instance id returned by bizar_spawn_background."),
+      message: z
+        .string()
+        .min(1)
+        .describe("The follow-up instruction to send."),
+    },
+    execute: async (rawArgs, ctx) => {
+      const args = rawArgs as { instanceId: string; message: string };
+      // Verify the instance exists so we don't silently accept bogus ids.
+      const inst = await deps.instanceManager.get(args.instanceId);
+      if (!inst) {
+        return {
+          output: JSON.stringify({
+            error: "instance_not_found",
+            instanceId: args.instanceId,
+          }),
+        };
+      }
+      deps.logger.debug(
+        `bizar: sendMessage(${args.instanceId}) — mid-flight steer unavailable in v0.8.0 subprocess mode`,
+      );
+      void ctx;
+      return {
+        output: JSON.stringify({
+          error: "unavailable_in_subprocess_mode",
+          message:
+            "v0.8.0 bg agents run as `opencode run` subprocesses and cannot accept a follow-up prompt mid-flight. " +
+            "Use the dashboard's `POST /api/background/<id>/steer` (Steer button on instance detail) which performs " +
+            "kill+restart with the new instruction appended to the original prompt. " +
+            "Or, if running headlessly, you can call `bizar_kill` followed by `bizar_spawn_background` " +
+            "with a combined prompt yourself.",
+          instanceId: args.instanceId,
+          dashboardHint: `POST /api/background/${args.instanceId}/steer`,
+        }),
+      };
+    },
+  });
+}

package/plugins/bizar/src/tools/bg-spawn.ts

@@ -245,6 +245,10 @@ export function createBgSpawnTool(deps: BgSpawnDeps) {
         persistent: args.persistent ?? false,
         maxRestarts: args.maxRestarts ?? 3,
         restartCount: 0,
+        // v5.x — progress reporting seed. Agents update via
+        // `bizar_report_progress`; the dashboard renders the bar.
+        progress: 0,
+        toolCalls: [],
       };
       const addRes = await deps.instanceManager.add(draft);
       if (addRes === "cap_reached") {
@@ -333,14 +337,17 @@ export function createBgSpawnTool(deps: BgSpawnDeps) {
         const { onExit } = await import("../opencode-runner.js");
         onExit(spawnRes.processId, (status) => {
           // Map runner states to BackgroundStatus. The runner reports
-          // "starting" | "running" | "done" | "failed" | "killed";
-          // BackgroundStatus has "pending" | "running" | "done" |
-          // "failed" | "killed" | "timed_out". "starting" maps to
-          // "running" (in-flight, no terminal state).
-          const mapped: "pending" | "running" | "done" | "failed" | "killed" =
+          // "starting" | "running" | "paused" | "done" | "failed" | "killed";
+          // BackgroundStatus has "pending" | "running" | "paused" | "done" |
+          // "failed" | "killed" | "timed_out" | "steered". "starting"
+          // maps to "running" (in-flight, no terminal state). "paused"
+          // is preserved so pause/resume survives subprocess reconnects.
+          const mapped: "pending" | "running" | "paused" | "done" | "failed" | "killed" =
             status.state === "starting" || status.state === "running"
               ? "running"
-              : status.state;
+              : status.state === "paused"
+                ? "paused"
+                : status.state;
 
           const update: Parameters<InstanceManager["update"]>[1] = {
             status: mapped,

package/plugins/bizar/src/tools/bg-status.ts

@@ -95,5 +95,15 @@ function toViewShape(inst: import("../background-state.js").BackgroundState): In
     if (inst.interventionAt !== undefined) v.interventionAt = inst.interventionAt;
     if (inst.interventionReason !== undefined) v.interventionReason = inst.interventionReason;
   }
+  // v5.x — extended dashboard surface.
+  if (Array.isArray(inst.toolCalls) && inst.toolCalls.length > 0) {
+    v.toolCalls = inst.toolCalls.slice();
+  }
+  if (typeof inst.progress === "number") v.progress = inst.progress;
+  if (inst.progressMessage !== undefined) v.progressMessage = inst.progressMessage;
+  if (inst.processId !== undefined) v.processId = inst.processId;
+  if (inst.runnerState !== undefined) v.runnerState = inst.runnerState;
+  if (Array.isArray(inst.tags) && inst.tags.length > 0) v.tags = inst.tags.slice();
+  if (inst.pausedAt !== undefined) v.pausedAt = inst.pausedAt;
   return v;
 }

package/plugins/bizar/src/tools/memory-list.ts

@@ -0,0 +1,135 @@
+/**
+ * plugins/bizar/src/tools/memory-list.ts
+ *
+ * `bizar_memory_list` tool — list notes in the Bizar Memory vault.
+ *
+ * Calls GET /api/memory/notes?prefix=... on the dashboard server.
+ * Returns an array of { path, title, updated, type } objects.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+import type { Logger } from "../logger.js";
+
+export interface MemoryListDeps {
+  worktree: string;
+  logger: Logger;
+}
+
+async function resolveDashboardPort(): Promise<number | null> {
+  const portFile = join(homedir(), ".config", "bizar", "dashboard.port");
+  if (existsSync(portFile)) {
+    try {
+      const raw = readFileSync(portFile, "utf8").trim();
+      const n = parseInt(raw, 10);
+      if (Number.isFinite(n) && n > 0 && n <= 65535) return n;
+    } catch {
+      // fall through
+    }
+  }
+  const envPort = process.env.BIZAR_DASHBOARD_PORT;
+  if (envPort) {
+    const n = parseInt(envPort, 10);
+    if (Number.isFinite(n) && n > 0 && n <= 65535) return n;
+  }
+  return null;
+}
+
+export function createMemoryListTool(deps: MemoryListDeps) {
+  return tool({
+    description:
+      "List notes in the Bizar Memory vault, optionally filtered by path prefix. " +
+      "Returns { notes: [{ path, title, updated, type }] }. " +
+      "Available to all agents.",
+    args: {
+      prefix: z
+        .string()
+        .optional()
+        .describe("Optional vault-relative path prefix to filter results " +
+          "(e.g. 'decisions/' lists all notes under decisions/)."),
+      limit: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .default(50)
+        .describe("Max notes to return (default 50)."),
+    },
+    execute: async (rawArgs) => {
+      const args = rawArgs as { prefix?: string; limit?: number };
+      const { logger } = deps;
+
+      const port = await resolveDashboardPort();
+      if (!port) {
+        return {
+          output: JSON.stringify({
+            error: "dashboard_not_running",
+            message: "The Bizar dashboard is not running. Start it with `bizar dash start`.",
+            notes: [],
+          }),
+        };
+      }
+
+      const params = new URLSearchParams();
+      if (args.prefix) {
+        params.set("prefix", args.prefix);
+      }
+      const limit = Math.min(args.limit ?? 50, 200);
+      params.set("limit", String(limit));
+
+      const url = `http://127.0.0.1:${port}/api/memory/notes?${params}`;
+
+      try {
+        const res = await fetch(url, { method: "GET" });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          logger.warn(`bizar: memory-list HTTP ${res.status}: ${text.slice(0, 200)}`);
+          return {
+            output: JSON.stringify({
+              error: "list_failed",
+              message: `HTTP ${res.status}: ${text.slice(0, 200)}`,
+              notes: [],
+            }),
+          };
+        }
+
+        const data = (await res.json()) as {
+          notes?: Array<{
+            relPath?: string;
+            frontmatter?: { title?: string; type?: string };
+            mtime?: number;
+          }>;
+          count?: number;
+        };
+
+        const notes = (data.notes ?? []).map((n) => ({
+          path: n.relPath ?? "",
+          title: n.frontmatter?.title ?? null,
+          updated: n.mtime ? new Date(n.mtime).toISOString() : null,
+          type: n.frontmatter?.type ?? null,
+        }));
+
+        return {
+          output: JSON.stringify({
+            notes,
+            count: notes.length,
+          }),
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`bizar: memory-list failed: ${msg}`);
+        return {
+          output: JSON.stringify({
+            error: "list_failed",
+            message: msg,
+            notes: [],
+          }),
+        };
+      }
+    },
+  });
+}

package/plugins/bizar/src/tools/memory-read.ts

@@ -0,0 +1,142 @@
+/**
+ * plugins/bizar/src/tools/memory-read.ts
+ *
+ * `bizar_memory_read` tool — read a single note from the Bizar Memory vault.
+ *
+ * Calls GET /api/memory/notes/:path on the dashboard server.
+ *
+ * The `path` is relative to the vault root (e.g. "decisions/foo.md"
+ * or "projects/myproj/sessions/2025-07-06.md").
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+import type { Logger } from "../logger.js";
+
+export interface MemoryReadDeps {
+  worktree: string;
+  logger: Logger;
+}
+
+async function resolveDashboardPort(): Promise<number | null> {
+  const portFile = join(homedir(), ".config", "bizar", "dashboard.port");
+  if (existsSync(portFile)) {
+    try {
+      const raw = readFileSync(portFile, "utf8").trim();
+      const n = parseInt(raw, 10);
+      if (Number.isFinite(n) && n > 0 && n <= 65535) return n;
+    } catch {
+      // fall through
+    }
+  }
+  const envPort = process.env.BIZAR_DASHBOARD_PORT;
+  if (envPort) {
+    const n = parseInt(envPort, 10);
+    if (Number.isFinite(n) && n > 0 && n <= 65535) return n;
+  }
+  return null;
+}
+
+export function createMemoryReadTool(deps: MemoryReadDeps) {
+  return tool({
+    description:
+      "Read a single note from the Bizar Memory vault. " +
+      "The path is relative to the vault root (e.g. 'decisions/foo.md'). " +
+      "Returns { path, content, frontmatter, mtime } or { error } on failure. " +
+      "Available to all agents.",
+    args: {
+      path: z
+        .string()
+        .min(1)
+        .describe("Vault-relative path of the note to read (e.g. 'decisions/foo.md')."),
+    },
+    execute: async (rawArgs) => {
+      const args = rawArgs as { path: string };
+      const { logger } = deps;
+
+      // Basic path safety: no absolute paths, no traversal above vault root
+      const normalized = args.path.replace(/\\/g, "/").replace(/^\/+/, "");
+      if (normalized.includes("..") || normalized.startsWith(".")) {
+        return {
+          output: JSON.stringify({
+            error: "invalid_path",
+            message: "Path must be a simple relative vault path (no '..' or absolute paths).",
+            path: args.path,
+          }),
+        };
+      }
+
+      const port = await resolveDashboardPort();
+      if (!port) {
+        return {
+          output: JSON.stringify({
+            error: "dashboard_not_running",
+            message: "The Bizar dashboard is not running. Start it with `bizar dash start`.",
+            path: args.path,
+          }),
+        };
+      }
+
+      const url = `http://127.0.0.1:${port}/api/memory/notes/${encodeURIComponent(normalized)}`;
+
+      try {
+        const res = await fetch(url, { method: "GET" });
+
+        if (res.status === 404) {
+          return {
+            output: JSON.stringify({
+              error: "not_found",
+              message: `Note not found at path: ${normalized}`,
+              path: normalized,
+            }),
+          };
+        }
+
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          logger.warn(`bizar: memory-read(${normalized}) HTTP ${res.status}: ${text.slice(0, 200)}`);
+          return {
+            output: JSON.stringify({
+              error: "read_failed",
+              message: `HTTP ${res.status}: ${text.slice(0, 200)}`,
+              path: normalized,
+            }),
+          };
+        }
+
+        const data = (await res.json()) as {
+          relPath?: string;
+          frontmatter?: Record<string, unknown>;
+          body?: string;
+          raw?: string;
+          mtime?: number;
+          size?: number;
+        };
+
+        return {
+          output: JSON.stringify({
+            path: data.relPath ?? normalized,
+            content: data.body ?? "",
+            frontmatter: data.frontmatter ?? {},
+            mtime: data.mtime ?? null,
+            size: data.size ?? null,
+          }),
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`bizar: memory-read(${normalized}) failed: ${msg}`);
+        return {
+          output: JSON.stringify({
+            error: "read_failed",
+            message: msg,
+            path: normalized,
+          }),
+        };
+      }
+    },
+  });
+}