@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/src/tools/read-glyph-feedback.ts

@@ -1,191 +0,0 @@
-/**
- * read-glyph-feedback.ts
- *
- * `read_glyph_feedback` tool (v3.22.0).
- *
- * Reads the structured `feedback.md` file the user wrote when they
- * clicked "Submit to agent" on a glyph in the dashboard. Returns:
- *   - parsed frontmatter (glyph, submittedAt, submittedBy, commentCount, questionCount)
- *   - the markdown body (Free-placed comments / Open-question answers / Full MDX source)
- *   - the parsed counts
- *
- * File location: `<worktree>/artifacts/<slug>/feedback.md`. The dashboard
- * writes this file via `POST /api/artifacts/:slug/submit` and marks the
- * artifact's `meta.json` `status` as `review`.
- *
- * Companion tools:
- *   - `bizar_get_plan_comments` — legacy canvas comment reader
- *   - `bizar_plan_action`      — CRUD on the v2 canvas
- *
- * Read-only — available to ALL agents. Never throws.
- *
- * Cline SDK port (Phase 2):
- *   - Uses `createTool` from `@cline/sdk` directly.
- *   - Adds `name: BIZAR_READ_GLYPH_FEEDBACK_TOOL_NAME`.
- *   - `inputSchema` is `z.object(...).shape` over the same fields as before.
- *   - Returns structured `{ ok: true, found, ... }` / `{ ok: false, error, ... }`
- *     instead of `{ output: JSON.stringify(...) }`.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import type { Logger } from "../logger.js";
-
-export const BIZAR_READ_GLYPH_FEEDBACK_TOOL_NAME = "bizar_read_glyph_feedback";
-
-export interface ReadGlyphFeedbackDeps {
-  /** The project's working directory (e.g. /home/user/proj). `artifacts/` is here. */
-  worktree: string;
-  logger: Logger;
-}
-
-// --- Constants -----------------------------------------------------------
-
-/** Same slug rule used everywhere in the project. */
-const SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,63}$/;
-
-// --- Return type ---------------------------------------------------------
-
-export interface ReadGlyphFeedbackResult {
-  ok: true;
-  found: true;
-  slug: string;
-  meta: Record<string, string>;
-  body: string;
-  feedbackFile: string;
-  commentCount: number;
-  questionCount: number;
-}
-
-export interface ReadGlyphFeedbackMissing {
-  ok: true;
-  found: false;
-  slug: string;
-  message: string;
-  feedbackFile: string;
-}
-
-export interface ReadGlyphFeedbackError {
-  ok: false;
-  error: string;
-  slug: string;
-}
-
-export type ReadGlyphFeedbackOutcome =
-  | ReadGlyphFeedbackResult
-  | ReadGlyphFeedbackMissing
-  | ReadGlyphFeedbackError;
-
-export type BizarReadGlyphFeedbackInput = z.infer<typeof bizarReadGlyphFeedbackSchema>;
-export type BizarReadGlyphFeedbackOutput = ReadGlyphFeedbackOutcome;
-
-const bizarReadGlyphFeedbackSchema = z.object({
-  slug: z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "Must match ^[a-z0-9][a-z0-9-]{0,63}$")
-    .describe("The artifact slug (e.g., 'dashboard-stale-pid-fix')."),
-});
-
-// --- Pure core: readGlyphFeedback ----------------------------------------
-
-/**
- * Read `artifacts/<slug>/feedback.md` from disk and parse it. Exported
- * so tests can drive the same code path the real tool uses.
- *
- * Behavior:
- *   - Invalid slug         → returns `{ ok: false, error }`
- *   - File missing         → returns `{ ok: true, found: false, message }`
- *   - File present, parseable → returns `{ ok: true, found: true, meta, body, ... }`
- *   - File present, corrupt   → returns `{ ok: true, found: true, meta: {}, body: raw }`
- *
- * Never throws.
- */
-export function readGlyphFeedback(
-  worktree: string,
-  slug: string,
-): ReadGlyphFeedbackOutcome {
-  if (!SLUG_REGEX.test(slug)) {
-    return {
-      ok: false,
-      error: `Invalid slug: "${slug}". Must match ^[a-z0-9][a-z0-9-]{0,63}$.`,
-      slug,
-    };
-  }
-
-  const feedbackFile = join(worktree, "artifacts", slug, "feedback.md");
-  if (!existsSync(feedbackFile)) {
-    return {
-      ok: true,
-      found: false,
-      slug,
-      message: `No feedback.md in artifacts/${slug}/ — has the user submitted feedback yet?`,
-      feedbackFile,
-    };
-  }
-
-  const raw = readFileSync(feedbackFile, "utf-8");
-
-  // Parse the YAML frontmatter. We only support scalar values (string /
-  // number) because the dashboard's writer only emits scalars.
-  const meta: Record<string, string> = {};
-  const fm = raw.match(/^---\n([\s\S]+?)\n---/);
-  let body = raw;
-  if (fm) {
-    const yaml = fm[1] ?? "";
-    for (const line of yaml.split("\n")) {
-      const m = line.match(/^(\w+):\s*(.*)$/);
-      if (m) meta[m[1]!] = m[2]!;
-    }
-    if (fm[0]) body = raw.slice(fm[0].length).replace(/^\s+/, "");
-  }
-
-  const commentCount = parseInt(meta.commentCount || "0", 10) || 0;
-  const questionCount = parseInt(meta.questionCount || "0", 10) || 0;
-
-  return {
-    ok: true,
-    found: true,
-    slug,
-    meta,
-    body,
-    feedbackFile,
-    commentCount,
-    questionCount,
-  };
-}
-
-// --- Tool factory --------------------------------------------------------
-
-/**
- * Build the `bizar_read_glyph_feedback` tool. The plugin wires the
- * result into `api.registerTool()` from `AgentExtensionApi`. The
- * `deps` closure carries the worktree and logger.
- */
-export function createReadGlyphFeedbackTool(
-  deps: ReadGlyphFeedbackDeps,
-): AgentTool<BizarReadGlyphFeedbackInput, BizarReadGlyphFeedbackOutput> {
-  return createTool({
-    name: BIZAR_READ_GLYPH_FEEDBACK_TOOL_NAME,
-    description:
-      "Reads feedback.md for a glyph the user submitted for review. " +
-      "Returns free-placed comments with (x, y) coordinates, answers to " +
-      "OpenQuestions, and the original MDX source. Use this to understand " +
-      "exactly what the user wants changed before regenerating the glyph.",
-    inputSchema: bizarReadGlyphFeedbackSchema.shape,
-    execute: async (input) => {
-      const result = readGlyphFeedback(deps.worktree, input.slug);
-      if (!result.ok) {
-        deps.logger.warn(
-          `bizar: read_glyph_feedback(${input.slug}) failed: ${result.error}`,
-        );
-      }
-      return result;
-    },
-  });
-}
-

package/plugins/bizar/src/tools/sandbox.ts

@@ -1,232 +0,0 @@
-/**
- * sandbox.ts — v6.3.0 CubeSandbox (E2B-compatible KVM microVM) tool.
- *
- * Adds two plugin tools:
- *   - bizar_sandbox_run   Run a script in a fresh CubeSandbox (or the
- *                         user's `base` template). Each call boots a new
- *                         microVM in <60ms with <5MB overhead, runs the
- *                         script, captures stdout/stderr/exit code, and
- *                         tears down. Hardware-isolated from the host.
- *   - bizar_sandbox_exec  Same, but reuses an existing sandbox id (avoids
- *                         cold start cost for chained calls).
- *
- * Why this exists:
- *   - The host shell is a shared resource that the loop-guard can't
- *     fully constrain; CubeSandbox gives us KVM-level isolation.
- *   - The dangerous-patterns hook can route risky `bash` calls here
- *     instead of asking the user to approve each one.
- *   - E2B SDK is Python, so we shell out to the existing
- *     `bizar sandbox run` CLI (which wraps the SDK).
- *
- * Requires:
- *   - `pip install cubesandbox`
- *   - CUBESANDBOX_API_KEY + CUBESANDBOX_URL set via `bizar sandbox config`
- *
- * Refs:
- *   - https://github.com/TencentCloud/CubeSandbox
- *   - ~/config/skills/cubesandbox/SKILL.md
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { execFile as cpExecFile } from "node:child_process";
-import { promisify } from "node:util";
-import { z } from "zod";
-
-import type { Logger } from "../logger.js";
-import { checkDangerous } from "../dangerous-patterns.js";
-
-const execFile = promisify(cpExecFile);
-
-export const BIZAR_SANDBOX_RUN_TOOL_NAME = "bizar_sandbox_run";
-export const BIZAR_SANDBOX_EXEC_TOOL_NAME = "bizar_sandbox_exec";
-
-export interface SandboxDeps {
-  /** Override the path to the `bizar` CLI (defaults to `bizar` on PATH). */
-  bizarBin?: string;
-  logger: Logger;
-}
-
-function resolveBizarBin(deps: SandboxDeps): string {
-  return deps.bizarBin ?? process.env.BIZAR_BIN ?? "bizar";
-}
-
-// ─── tool: bizar_sandbox_run ──────────────────────────────────────────────
-const sandboxRunSchema = z.object({
-  language: z
-    .enum(["bash", "python", "node"])
-    .default("bash")
-    .describe("The script language. Defaults to bash."),
-  script: z
-    .string()
-    .min(1)
-    .max(64_000)
-    .describe("The script body. Multi-line scripts are fine."),
-  template: z
-    .string()
-    .optional()
-    .describe(
-      "CubeSandbox template name. Defaults to env CUBESANDBOX_TEMPLATE or `base`.",
-    ),
-  proxy_credentials: z
-    .record(z.string(), z.string())
-    .optional()
-    .describe(
-      "Map of credential name → value to inject at the egress proxy. Optional; keys never enter the sandbox.",
-    ),
-  timeout_seconds: z
-    .number()
-    .int()
-    .min(1)
-    .max(600)
-    .default(120)
-    .describe("Sandbox boot + script execution timeout."),
-});
-
-export type SandboxRunInput = z.infer<typeof sandboxRunSchema>;
-export type SandboxRunOutput = {
-  ok: boolean;
-  blocked?: boolean;
-  reason?: string;
-  sandbox_id?: string;
-  stdout?: string;
-  stderr?: string;
-  exit_code?: number;
-  duration_ms?: number;
-  error?: string;
-};
-
-export function createSandboxRunTool(deps: SandboxDeps): AgentTool<
-  SandboxRunInput,
-  SandboxRunOutput
-> {
-  const bizarBin = resolveBizarBin(deps);
-  return createTool({
-    name: BIZAR_SANDBOX_RUN_TOOL_NAME,
-    description:
-      "Run a script in a fresh CubeSandbox (KVM-isolated microVM, E2B-compatible). Use for any `bash`/`python`/`node` call whose side effects should not escape the sandbox (file writes under ~/.config, package installs, network probes, third-party scripts, eval code). Boots in <60ms with <5MB overhead. Each call is one-shot. For chained commands, use `bizar_sandbox_exec` with the returned `sandbox_id`.",
-    inputSchema: sandboxRunSchema.shape,
-    execute: async (input) => {
-      const t0 = Date.now();
-
-      const verdict = checkDangerous({
-        script: input.script,
-        language: input.language,
-      });
-      if (verdict && verdict.decision === "deny") {
-        return {
-          ok: false,
-          blocked: true,
-          reason: verdict.reason,
-        };
-      }
-
-      const args = ["sandbox", "run", input.language, input.script];
-      if (input.template) args.push("--template", input.template);
-      if (input.timeout_seconds)
-        args.push("--timeout", String(input.timeout_seconds));
-      if (input.proxy_credentials) {
-        for (const [k, v] of Object.entries(input.proxy_credentials)) {
-          args.push("--proxy-credential", `${k}=${v}`);
-        }
-      }
-
-      try {
-        const { stdout, stderr } = await execFile(bizarBin, args, {
-          timeout: (input.timeout_seconds + 5) * 1000,
-          maxBuffer: 16 * 1024 * 1024,
-        });
-        // `bizar sandbox run` returns JSON {"sandbox_id":..., "stdout":..., "stderr":..., "exit_code":...}
-        let parsed: {
-          sandbox_id?: string;
-          stdout?: string;
-          stderr?: string;
-          exit_code?: number;
-        } | null = null;
-        try {
-          parsed = JSON.parse(stdout);
-        } catch {
-          // raw text — fall through
-        }
-        if (parsed && typeof parsed.exit_code === "number") {
-          return {
-            ok: parsed.exit_code === 0,
-            sandbox_id: parsed.sandbox_id,
-            stdout: parsed.stdout ?? "",
-            stderr: parsed.stderr ?? "",
-            exit_code: parsed.exit_code,
-            duration_ms: Date.now() - t0,
-          };
-        }
-        return {
-          ok: true,
-          stdout,
-          stderr,
-          exit_code: 0,
-          duration_ms: Date.now() - t0,
-        };
-      } catch (err) {
-        const e = err as {
-          stdout?: string;
-          stderr?: string;
-          code?: number;
-        };
-        return {
-          ok: false,
-          stdout: e.stdout ?? "",
-          stderr: e.stderr ?? String(err),
-          exit_code: typeof e.code === "number" ? e.code : 1,
-          duration_ms: Date.now() - t0,
-        };
-      }
-    },
-  });
-}
-
-// ─── tool: bizar_sandbox_exec ─────────────────────────────────────────────
-const sandboxExecSchema = z.object({
-  sandbox_id: z
-    .string()
-    .min(1)
-    .describe("The CubeSandbox id returned by `bizar_sandbox_run`."),
-  script: z.string().min(1).max(64_000).describe("Script body to run."),
-});
-
-export type SandboxExecInput = z.infer<typeof sandboxExecSchema>;
-export type SandboxExecOutput = {
-  ok: boolean;
-  blocked?: boolean;
-  reason?: string;
-  stdout?: string;
-  stderr?: string;
-  error?: string;
-};
-
-export function createSandboxExecTool(deps: SandboxDeps): AgentTool<
-  SandboxExecInput,
-  SandboxExecOutput
-> {
-  const bizarBin = resolveBizarBin(deps);
-  return createTool({
-    name: BIZAR_SANDBOX_EXEC_TOOL_NAME,
-    description:
-      "Run a script in an existing CubeSandbox (avoids cold-start cost for chained calls). Pass the `sandbox_id` returned by a previous `bizar_sandbox_run`. Same scripts, same isolation, no boot.",
-    inputSchema: sandboxExecSchema.shape,
-    execute: async (input) => {
-      const verdict = checkDangerous({ script: input.script });
-      if (verdict && verdict.decision === "deny") {
-        return { ok: false, blocked: true, reason: verdict.reason };
-      }
-
-      try {
-        const { stdout } = await execFile(
-          bizarBin,
-          ["sandbox", "exec", input.sandbox_id, input.script],
-          { timeout: 300_000, maxBuffer: 16 * 1024 * 1024 },
-        );
-        return { ok: true, stdout };
-      } catch (err) {
-        return { ok: false, error: String(err) };
-      }
-    },
-  });
-}

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

@@ -1,73 +0,0 @@
-/**
- * team-spawn.ts
- *
- * `bizar_spawn_team` tool — spawn a Cline agent team (multi-agent
- * collaboration). Uses ClineCore in-process with `enableAgentTeams: true`.
- *
- * A team is a set of agents that collaborate on a shared mission. The
- * lead agent coordinates; teammates execute sub-tasks. The team runs
- * until the mission is complete or the team is stopped.
- *
- * v6.0.0 — New tool for Cline agent teams integration. The runtime
- * config sets `enableAgentTeams: true` so the team coordinator + tools
- * (TeamSpawnTeammate, TeamRunTask, TeamSendMessage, etc.) are available.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-
-import type { ClineRuntime, StartSessionOpts } from "../clineruntime.js";
-import type { Logger } from "../logger.js";
-
-export const BIZAR_SPAWN_TEAM_TOOL_NAME = "bizar_spawn_team";
-
-export interface TeamSpawnDeps {
-  runtime: ClineRuntime;
-  logger: Logger;
-}
-
-export type BizarTeamSpawnInput = z.infer<typeof bizarTeamSpawnSchema>;
-export type BizarTeamSpawnOutput =
-  | { ok: true; sessionId: string; teamName: string; missionPreview: string }
-  | { ok: false; error: string; message: string };
-
-const bizarTeamSpawnSchema = z.object({
-  teamName: z.string().min(1).describe("Name of the team (e.g. 'bizar-build-team')."),
-  mission: z.string().min(1).describe("The mission/goal for the team. The lead agent will coordinate teammates to achieve this."),
-  providerId: z.string().optional().describe("Provider ID (default 'anthropic')."),
-  modelId: z.string().optional().describe("Model ID (default 'claude-sonnet-4-6')."),
-  workspaceRoot: z.string().optional().describe("Workspace root (default worktree)."),
-});
-
-export function createTeamSpawnTool(
-  deps: TeamSpawnDeps,
-): AgentTool<BizarTeamSpawnInput, BizarTeamSpawnOutput> {
-  return createTool({
-    name: BIZAR_SPAWN_TEAM_TOOL_NAME,
-    description:
-      "Spawn a Cline agent team. The lead agent coordinates teammates " +
-      "to complete the mission. Returns the team sessionId. Available to " +
-      "Odin and coordinating agents.",
-    inputSchema: bizarTeamSpawnSchema.shape,
-    execute: async (input) => {
-      const opts: StartSessionOpts = {
-        providerId: input.providerId ?? "anthropic",
-        modelId: input.modelId ?? "claude-sonnet-4-6",
-        workspaceRoot: input.workspaceRoot ?? process.cwd(),
-        systemPrompt: `You are the lead agent of the "${input.teamName}" team. Your mission:\n\n${input.mission}\n\nUse Cline's team tools to coordinate teammates: spawn teammates, run tasks, send messages, review outcomes, and finalize. Use the team progress event stream to track work.`,
-        prompt: `Start the "${input.teamName}" team. Mission: ${input.mission}`,
-        source: "bizar-team-spawn",
-        sessionMetadata: { bizarTeam: input.teamName, bizarMission: input.mission.slice(0, 500) },
-      };
-      try {
-        const sessionId = await deps.runtime.startSession(opts);
-        deps.logger.info(`bizar: team spawned (teamName=${input.teamName}, sessionId=${sessionId})`);
-        return { ok: true as const, sessionId, teamName: input.teamName, missionPreview: input.mission.slice(0, 200) };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        deps.logger.warn(`bizar: team spawn failed: ${msg}`);
-        return { ok: false as const, error: "spawn_failed", message: msg };
-      }
-    },
-  });
-}

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

@@ -1,76 +0,0 @@
-/**
- * team-status.ts
- *
- * `bizar_team_status` tool — get the current status of a Cline agent team.
- * Subscribes to team events and returns a snapshot of progress.
- *
- * v6.0.0 — Cline agent teams integration. The dashboard's kanban board
- * consumes these events to show team progress in real time.
- */
-
-import { createTool, type AgentTool } from "@cline/sdk";
-import { z } from "zod";
-import type { CoreSessionEvent } from "@cline/core";
-
-import type { ClineRuntime } from "../clineruntime.js";
-import type { Logger } from "../logger.js";
-
-export const BIZAR_TEAM_STATUS_TOOL_NAME = "bizar_team_status";
-
-export interface TeamStatusDeps {
-  runtime: ClineRuntime;
-  logger: Logger;
-}
-
-export type BizarTeamStatusInput = z.infer<typeof bizarTeamStatusSchema>;
-export type BizarTeamStatusOutput =
-  | { ok: true; sessionId: string; teamProgress: unknown }
-  | { ok: false; error: string; message: string };
-
-const bizarTeamStatusSchema = z.object({
-  sessionId: z.string().min(1).describe("Team session ID returned by bizar_spawn_team."),
-  timeoutMs: z.number().int().positive().optional().describe("Max time to wait for a progress event (default 1000ms)."),
-});
-
-/**
- * Subscribe to team events for a session and return the most recent
- * team_progress_projection event. If no progress event is available
- * within the timeout, returns what we have (or null).
- */
-export function createTeamStatusTool(
-  deps: TeamStatusDeps,
-): AgentTool<BizarTeamStatusInput, BizarTeamStatusOutput> {
-  return createTool({
-    name: BIZAR_TEAM_STATUS_TOOL_NAME,
-    description:
-      "Get the current status of a Cline agent team. Returns the latest " +
-      "team progress projection. Available to Odin and coordinating agents.",
-    inputSchema: bizarTeamStatusSchema.shape,
-    execute: async (input) => {
-      const timeoutMs = input.timeoutMs ?? 1000;
-      let lastProgress: unknown = null;
-      let done = false;
-      const handler = (event: CoreSessionEvent) => {
-        const t = (event as { type?: string }).type;
-        if (t === "team_progress_projection" || t === "team.lifecycle" || t === "team.progress" || t === "team.lifecycle.v1") {
-          lastProgress = event;
-          done = true;
-        }
-      };
-      let unsubscribe: (() => void) | null = null;
-      try {
-        unsubscribe = deps.runtime.subscribe({ sessionId: input.sessionId }, handler);
-        const start = Date.now();
-        while (!done && Date.now() - start < timeoutMs) {
-          await new Promise((r) => setTimeout(r, 50));
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        deps.logger.warn(`bizar: team-status subscribe failed: ${msg}`);
-      } finally {
-        try { unsubscribe?.(); } catch { /* ignore */ }
-      }
-      return { ok: true as const, sessionId: input.sessionId, teamProgress: lastProgress };
-    },
-  });
-}