@kortix/sandbox 0.4.1

package/opencode/tools/show-user.ts

@@ -0,0 +1,217 @@
+import { tool } from "@opencode-ai/plugin";
+import {
+  writeFileSync,
+  readFileSync,
+  mkdirSync,
+  existsSync,
+  appendFileSync,
+} from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir } from "os";
+
+const SHOW_DIR = join(process.env.HOME || homedir(), ".show-user");
+const QUEUE_FILE = `${SHOW_DIR}/queue.jsonl`;
+
+interface ShowEntry {
+  id: string;
+  timestamp: string;
+  type: "file" | "url" | "image" | "text" | "error";
+  title?: string;
+  description?: string;
+  path?: string;
+  url?: string;
+  content?: string;
+  metadata?: Record<string, unknown>;
+}
+
+function ensureShowDir(): void {
+  mkdirSync(SHOW_DIR, { recursive: true });
+}
+
+function generateId(): string {
+  return `show_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function appendToQueue(entry: ShowEntry): void {
+  ensureShowDir();
+  appendFileSync(QUEUE_FILE, JSON.stringify(entry) + "\n");
+}
+
+function readQueue(): ShowEntry[] {
+  if (!existsSync(QUEUE_FILE)) return [];
+  const content = readFileSync(QUEUE_FILE, "utf-8").trim();
+  if (!content) return [];
+  return content
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as ShowEntry;
+      } catch {
+        return null;
+      }
+    })
+    .filter((e): e is ShowEntry => e !== null);
+}
+
+function clearQueue(): void {
+  ensureShowDir();
+  writeFileSync(QUEUE_FILE, "");
+}
+
+export default tool({
+  description:
+    "Show outputs and attachments to the human user. Use this tool to present files, images, URLs, " +
+    "text content, or error messages to the user. Items are appended to a queue that the user's UI " +
+    "reads from. Actions: 'show' (add item to queue), 'list' (list queued items), 'clear' (clear queue). " +
+    "Always use this after generating a deliverable (image, document, video, presentation, etc.) " +
+    "so the human can see and access it.",
+  args: {
+    action: tool.schema
+      .string()
+      .describe(
+        "Action to perform: 'show' (add item to queue), 'list' (list queued items), 'clear' (clear the queue)",
+      ),
+    type: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Type of item to show. Required for 'show' action. " +
+          "Options: 'file' (any file on disk), 'image' (image file), 'url' (web link), " +
+          "'text' (inline text content), 'error' (error message for user)",
+      ),
+    title: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Short title for the item (displayed as heading). E.g. 'Generated Logo', 'Research Report'",
+      ),
+    description: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Optional longer description of the item. E.g. 'A 1024x1024 logo based on your brand colors'",
+      ),
+    path: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Absolute path to a file on disk. Required when type is 'file' or 'image'. " +
+          "E.g. '/workspace/output/logo.png'",
+      ),
+    url: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "URL to show the user. Required when type is 'url'. " +
+          "E.g. 'https://example.com/report'",
+      ),
+    content: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Inline text content to show. Required when type is 'text' or 'error'. " +
+          "Supports markdown formatting.",
+      ),
+    metadata: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Optional JSON string of extra metadata. E.g. '{\"width\":1024,\"format\":\"png\"}'",
+      ),
+  },
+  async execute(args, _context) {
+    const action = args.action;
+
+    if (!["show", "list", "clear"].includes(action)) {
+      return `Error: Invalid action '${action}'. Use 'show', 'list', or 'clear'.`;
+    }
+
+    // --- LIST ---
+    if (action === "list") {
+      const entries = readQueue();
+      if (entries.length === 0) {
+        return JSON.stringify(
+          { success: true, action: "list", count: 0, items: [] },
+          null,
+          2,
+        );
+      }
+      return JSON.stringify(
+        { success: true, action: "list", count: entries.length, items: entries },
+        null,
+        2,
+      );
+    }
+
+    // --- CLEAR ---
+    if (action === "clear") {
+      clearQueue();
+      return JSON.stringify(
+        { success: true, action: "clear", message: "Queue cleared." },
+        null,
+        2,
+      );
+    }
+
+    // --- SHOW ---
+    const type = args.type as ShowEntry["type"] | undefined;
+    if (!type || !["file", "image", "url", "text", "error"].includes(type)) {
+      return `Error: 'type' is required for 'show' action. Use 'file', 'image', 'url', 'text', or 'error'.`;
+    }
+
+    // Validate required fields per type
+    if ((type === "file" || type === "image") && !args.path) {
+      return `Error: 'path' is required when type is '${type}'.`;
+    }
+    if (type === "url" && !args.url) {
+      return `Error: 'url' is required when type is 'url'.`;
+    }
+    if ((type === "text" || type === "error") && !args.content) {
+      return `Error: 'content' is required when type is '${type}'.`;
+    }
+
+    // Verify file exists for file/image types
+    if ((type === "file" || type === "image") && args.path) {
+      const absPath = resolve(args.path);
+      if (!existsSync(absPath)) {
+        return `Error: File not found: ${absPath}`;
+      }
+    }
+
+    // Parse optional metadata
+    let metadata: Record<string, unknown> | undefined;
+    if (args.metadata) {
+      try {
+        metadata = JSON.parse(args.metadata);
+      } catch {
+        return `Error: Invalid JSON in 'metadata' parameter.`;
+      }
+    }
+
+    const entry: ShowEntry = {
+      id: generateId(),
+      timestamp: new Date().toISOString(),
+      type,
+      ...(args.title && { title: args.title }),
+      ...(args.description && { description: args.description }),
+      ...(args.path && { path: resolve(args.path) }),
+      ...(args.url && { url: args.url }),
+      ...(args.content && { content: args.content }),
+      ...(metadata && { metadata }),
+    };
+
+    appendToQueue(entry);
+
+    return JSON.stringify(
+      {
+        success: true,
+        action: "show",
+        entry,
+        message: `Item '${args.title || type}' added to show queue.`,
+      },
+      null,
+      2,
+    );
+  },
+});

package/opencode/tools/tests/e2e-presentation-fix.ts

@@ -0,0 +1,277 @@
+/**
+ * E2E test for the presentation-gen EACCES fix.
+ *
+ * Simulates the exact Docker sandbox scenario:
+ *   - _context.worktree = "/"  (no git repo)
+ *   - _context.directory = process.cwd()  (e.g. /workspace)
+ *   - NO output_dir provided
+ *
+ * Verifies that slides are created under cwd, not under "/presentations".
+ */
+import { existsSync, rmSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+
+// ── Helpers ──
+
+function pass(name: string) {
+  process.stdout.write(`  PASS  ${name}\n`);
+}
+function fail(name: string, reason: string) {
+  process.stdout.write(`  FAIL  ${name}: ${reason}\n`);
+  process.exit(1);
+}
+function assert(cond: boolean, name: string, reason: string) {
+  if (cond) pass(name);
+  else fail(name, reason);
+}
+
+// ── Setup ──
+
+const TEST_DIR = resolve(import.meta.dir, "e2e-output");
+rmSync(TEST_DIR, { recursive: true, force: true });
+
+// Import the tool
+const presGen = (await import("../presentation-gen.ts")).default;
+
+process.stdout.write("\n=== E2E: presentation-gen EACCES fix ===\n\n");
+
+// ── Test 1: worktree="/" without output_dir should NOT try to mkdir /presentations ──
+
+process.stdout.write("Test 1: worktree='/' falls back to _context.directory\n");
+{
+  const ctx = { directory: TEST_DIR, worktree: "/" } as Parameters<
+    typeof presGen.execute
+  >[1];
+
+  const raw = await presGen.execute(
+    {
+      action: "create_slide",
+      presentation_name: "e2e_test",
+      slide_number: 1,
+      slide_title: "Title Slide",
+      content:
+        '<div style="width:1920px;height:1080px;background:#111;display:flex;align-items:center;justify-content:center;"><h1 style="color:#fff;font-size:64px;">E2E Test</h1></div>',
+      presentation_title: "E2E Test Presentation",
+      // NOTE: no output_dir — this is the bug scenario
+    },
+    ctx,
+  );
+
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "create_slide succeeds", `got: ${raw}`);
+  assert(
+    result.presentation_path === "presentations/e2e_test",
+    "presentation_path is relative",
+    `got: ${result.presentation_path}`,
+  );
+
+  // Verify the file was created under TEST_DIR, not under /
+  const slidePath = join(TEST_DIR, result.slide_file);
+  assert(
+    existsSync(slidePath),
+    `slide file exists at ${slidePath}`,
+    "file not found",
+  );
+  assert(
+    !existsSync("/presentations/e2e_test"),
+    "nothing created at /presentations/e2e_test",
+    "files were incorrectly created at filesystem root!",
+  );
+
+  // Verify HTML content
+  const html = readFileSync(slidePath, "utf-8");
+  assert(html.includes("1920"), "slide has 1920 viewport", "missing viewport");
+  assert(html.includes("E2E Test"), "slide has content", "missing content");
+}
+
+// ── Test 2: Create multiple slides in "parallel" (sequential but no output_dir) ──
+
+process.stdout.write("\nTest 2: Multiple slides without output_dir\n");
+{
+  const ctx = { directory: TEST_DIR, worktree: "/" } as Parameters<
+    typeof presGen.execute
+  >[1];
+
+  for (let i = 2; i <= 5; i++) {
+    const raw = await presGen.execute(
+      {
+        action: "create_slide",
+        presentation_name: "e2e_test",
+        slide_number: i,
+        slide_title: `Slide ${i}`,
+        content: `<div style="width:1920px;height:1080px;background:#222;padding:60px;box-sizing:border-box;"><h2 style="color:#0ff;font-size:48px;">Slide ${i}</h2></div>`,
+        presentation_title: "E2E Test Presentation",
+      },
+      ctx,
+    );
+    const result = JSON.parse(raw as string);
+    assert(
+      result.success === true,
+      `slide ${i} created`,
+      `failed: ${raw}`,
+    );
+  }
+
+  // Verify all 5 slides exist
+  const listRaw = await presGen.execute(
+    { action: "list_slides", presentation_name: "e2e_test" },
+    ctx,
+  );
+  const listResult = JSON.parse(listRaw as string);
+  assert(
+    listResult.total_slides === 5,
+    `list_slides returns 5`,
+    `got ${listResult.total_slides}`,
+  );
+}
+
+// ── Test 3: images/ directory created correctly ──
+
+process.stdout.write("\nTest 3: images/ directory created under correct path\n");
+{
+  const imagesDir = join(TEST_DIR, "presentations", "images");
+  assert(existsSync(imagesDir), "images/ dir exists under TEST_DIR", "not found");
+  assert(
+    !existsSync("/presentations/images"),
+    "no images/ at filesystem root",
+    "images dir incorrectly at /",
+  );
+}
+
+// ── Test 4: metadata.json is correct ──
+
+process.stdout.write("\nTest 4: metadata.json structure\n");
+{
+  const metaPath = join(TEST_DIR, "presentations", "e2e_test", "metadata.json");
+  assert(existsSync(metaPath), "metadata.json exists", "not found");
+  const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+  assert(
+    meta.presentation_name === "e2e_test",
+    "presentation_name correct",
+    `got: ${meta.presentation_name}`,
+  );
+  assert(
+    meta.title === "E2E Test Presentation",
+    "title correct",
+    `got: ${meta.title}`,
+  );
+  assert(
+    Object.keys(meta.slides).length === 5,
+    "5 slides in metadata",
+    `got: ${Object.keys(meta.slides).length}`,
+  );
+}
+
+// ── Test 5: viewer.html generated ──
+
+process.stdout.write("\nTest 5: viewer.html generated\n");
+{
+  const viewerPath = join(TEST_DIR, "presentations", "e2e_test", "viewer.html");
+  // viewer.html depends on the skill template existing — might not in test env
+  if (existsSync(viewerPath)) {
+    pass("viewer.html exists");
+  } else {
+    process.stdout.write("  SKIP  viewer.html (skill template not available in test env)\n");
+  }
+}
+
+// ── Test 6: list_presentations works ──
+
+process.stdout.write("\nTest 6: list_presentations\n");
+{
+  const ctx = { directory: TEST_DIR, worktree: "/" } as Parameters<
+    typeof presGen.execute
+  >[1];
+  const raw = await presGen.execute(
+    { action: "list_presentations" },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "list succeeds", `got: ${raw}`);
+  assert(
+    result.total_count === 1,
+    "1 presentation found",
+    `got: ${result.total_count}`,
+  );
+  assert(
+    result.presentations[0].total_slides === 5,
+    "presentation has 5 slides",
+    `got: ${result.presentations[0].total_slides}`,
+  );
+}
+
+// ── Test 7: delete_slide works ──
+
+process.stdout.write("\nTest 7: delete_slide\n");
+{
+  const ctx = { directory: TEST_DIR, worktree: "/" } as Parameters<
+    typeof presGen.execute
+  >[1];
+  const raw = await presGen.execute(
+    { action: "delete_slide", presentation_name: "e2e_test", slide_number: 5 },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "delete succeeds", `got: ${raw}`);
+  assert(
+    result.remaining_slides === 4,
+    "4 slides remaining",
+    `got: ${result.remaining_slides}`,
+  );
+}
+
+// ── Test 8: delete_presentation works ──
+
+process.stdout.write("\nTest 8: delete_presentation\n");
+{
+  const ctx = { directory: TEST_DIR, worktree: "/" } as Parameters<
+    typeof presGen.execute
+  >[1];
+  const raw = await presGen.execute(
+    { action: "delete_presentation", presentation_name: "e2e_test" },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "delete presentation succeeds", `got: ${raw}`);
+
+  const presDir = join(TEST_DIR, "presentations", "e2e_test");
+  assert(!existsSync(presDir), "presentation dir removed", "still exists");
+}
+
+// ── Test 9: worktree with valid path still works (non-"/" case) ──
+
+process.stdout.write("\nTest 9: valid worktree still works\n");
+{
+  const ctx = { directory: "/tmp", worktree: TEST_DIR } as Parameters<
+    typeof presGen.execute
+  >[1];
+  const raw = await presGen.execute(
+    {
+      action: "create_slide",
+      presentation_name: "worktree_pres",
+      slide_number: 1,
+      slide_title: "Valid Worktree",
+      content: '<div style="width:1920px;height:1080px;background:#333;"><h1 style="color:#fff;">Worktree Test</h1></div>',
+      presentation_title: "Worktree Test",
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "create with valid worktree", `got: ${raw}`);
+  // Should use worktree (TEST_DIR), not directory (/tmp)
+  const slidePath = join(TEST_DIR, result.slide_file);
+  assert(existsSync(slidePath), "file under worktree dir", "not found");
+  assert(
+    !existsSync(join("/tmp", result.slide_file)),
+    "not under /tmp",
+    "incorrectly used directory instead of worktree",
+  );
+  // Cleanup
+  rmSync(join(TEST_DIR, "presentations", "worktree_pres"), { recursive: true, force: true });
+}
+
+// ── Cleanup ──
+
+rmSync(TEST_DIR, { recursive: true, force: true });
+
+process.stdout.write("\n=== All E2E tests passed! ===\n\n");

package/opencode/tools/tests/image-gen.test.ts

@@ -0,0 +1,215 @@
+import { readFileSync, existsSync, rmSync } from "fs";
+import { resolve } from "path";
+
+const envPath = resolve(import.meta.dir, "../../.env");
+for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) continue;
+  const eq = trimmed.indexOf("=");
+  if (eq > 0) process.env[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+}
+
+const OUTPUT_DIR = resolve(import.meta.dir, "test-output");
+
+async function test(name: string, fn: () => Promise<void>) {
+  process.stdout.write(`\n=== ${name} ===\n`);
+  try {
+    await fn();
+    process.stdout.write(`PASS\n`);
+  } catch (e) {
+    process.stdout.write(`FAIL: ${e}\n`);
+    process.exit(1);
+  }
+}
+
+function assert(cond: boolean, msg: string) {
+  if (!cond) throw new Error(msg);
+}
+
+const imageGen = (await import("../image-gen.ts")).default;
+
+const ctx = { directory: process.cwd(), worktree: process.cwd() } as Parameters<
+  typeof imageGen.execute
+>[1];
+
+// ── Validation Tests (no API calls) ──
+
+await test("image_gen: missing API key", async () => {
+  const saved = process.env.REPLICATE_API_TOKEN;
+  delete process.env.REPLICATE_API_TOKEN;
+  const raw = await imageGen.execute(
+    { action: "generate", prompt: "test" },
+    ctx,
+  );
+  process.env.REPLICATE_API_TOKEN = saved;
+  assert(
+    (raw as string).includes("REPLICATE_API_TOKEN"),
+    "should mention missing key",
+  );
+});
+
+await test("image_gen: invalid action", async () => {
+  const raw = await imageGen.execute({ action: "dance" }, ctx);
+  assert(
+    (raw as string).includes("Invalid action"),
+    "should reject invalid action",
+  );
+});
+
+await test("image_gen: generate without prompt", async () => {
+  const raw = await imageGen.execute({ action: "generate" }, ctx);
+  assert((raw as string).includes("prompt"), "should require prompt");
+});
+
+await test("image_gen: edit without image_path", async () => {
+  const raw = await imageGen.execute(
+    {
+      action: "edit",
+      prompt: "make it blue",
+    },
+    ctx,
+  );
+  assert((raw as string).includes("image_path"), "should require image_path");
+});
+
+await test("image_gen: upscale without image_path", async () => {
+  const raw = await imageGen.execute({ action: "upscale" }, ctx);
+  assert((raw as string).includes("image_path"), "should require image_path");
+});
+
+await test("image_gen: remove_bg without image_path", async () => {
+  const raw = await imageGen.execute({ action: "remove_bg" }, ctx);
+  assert((raw as string).includes("image_path"), "should require image_path");
+});
+
+// ── Live API Tests ──
+
+let generatedImagePath = "";
+
+await test("image_gen: generate image", async () => {
+  const raw = await imageGen.execute(
+    {
+      action: "generate",
+      prompt: "a simple red circle on white background",
+      size: "1024x1024",
+      quality: "low",
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, `expected success: ${raw}`);
+  assert(typeof result.output_path === "string", "should have output_path");
+  assert(
+    existsSync(result.output_path),
+    `file should exist: ${result.output_path}`,
+  );
+
+  const fileSize = readFileSync(result.output_path).length;
+  assert(fileSize > 1000, `file too small (${fileSize} bytes), likely empty`);
+
+  generatedImagePath = result.output_path;
+  process.stdout.write(`  saved: ${result.output_path} (${fileSize} bytes)\n`);
+});
+
+await test("image_gen: edit image", async () => {
+  assert(
+    generatedImagePath.length > 0,
+    "need generated image from previous test",
+  );
+
+  const raw = await imageGen.execute(
+    {
+      action: "edit",
+      prompt: "change the red circle to a blue square",
+      image_path: generatedImagePath,
+      quality: "low",
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, `expected success: ${raw}`);
+  assert(existsSync(result.output_path), "edited file should exist");
+
+  const fileSize = readFileSync(result.output_path).length;
+  process.stdout.write(`  saved: ${result.output_path} (${fileSize} bytes)\n`);
+});
+
+await test("image_gen: upscale image", async () => {
+  assert(
+    generatedImagePath.length > 0,
+    "need generated image from previous test",
+  );
+
+  const raw = await imageGen.execute(
+    {
+      action: "upscale",
+      image_path: generatedImagePath,
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, `expected success: ${raw}`);
+  assert(existsSync(result.output_path), "upscaled file should exist");
+
+  const origSize = readFileSync(generatedImagePath).length;
+  const upscaledSize = readFileSync(result.output_path).length;
+  process.stdout.write(
+    `  original: ${origSize} bytes -> upscaled: ${upscaledSize} bytes\n`,
+  );
+});
+
+await test("image_gen: remove background", async () => {
+  assert(
+    generatedImagePath.length > 0,
+    "need generated image from previous test",
+  );
+
+  const raw = await imageGen.execute(
+    {
+      action: "remove_bg",
+      image_path: generatedImagePath,
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, `expected success: ${raw}`);
+  assert(existsSync(result.output_path), "bg-removed file should exist");
+  assert(
+    result.output_path.endsWith(".png"),
+    "bg-removed should be PNG (transparency)",
+  );
+
+  const fileSize = readFileSync(result.output_path).length;
+  process.stdout.write(`  saved: ${result.output_path} (${fileSize} bytes)\n`);
+});
+
+await test("image_gen: nonexistent input image", async () => {
+  const raw = await imageGen.execute(
+    {
+      action: "upscale",
+      image_path: "/tmp/does-not-exist-12345.png",
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === false, "should fail for nonexistent image");
+  assert(
+    result.error.includes("not found") || result.error.includes("not exist"),
+    "should mention file not found",
+  );
+});
+
+// ── Cleanup (skip with --keep-output) ──
+
+if (!process.argv.includes("--keep-output")) {
+  try {
+    rmSync(OUTPUT_DIR, { recursive: true, force: true });
+  } catch {}
+}
+
+process.stdout.write("\n\nAll image-gen tests passed!\n");