@kortix/sandbox 0.4.1

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

@@ -0,0 +1,110 @@
+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-video");
+
+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 videoGen = (await import("../video-gen.ts")).default;
+
+const ctx = { directory: process.cwd(), worktree: process.cwd() } as Parameters<
+  typeof videoGen.execute
+>[1];
+
+// ── Validation Tests (no API calls) ──
+
+await test("video_gen: missing API key", async () => {
+  const saved = process.env.REPLICATE_API_TOKEN;
+  delete process.env.REPLICATE_API_TOKEN;
+  const raw = await videoGen.execute({ prompt: "test" }, ctx);
+  process.env.REPLICATE_API_TOKEN = saved;
+  assert(
+    (raw as string).includes("REPLICATE_API_TOKEN"),
+    "should mention missing key",
+  );
+});
+
+await test("video_gen: missing prompt", async () => {
+  const raw = await videoGen.execute({} as any, ctx);
+  assert((raw as string).includes("prompt"), "should require prompt");
+});
+
+await test("video_gen: nonexistent input image", async () => {
+  const raw = await videoGen.execute(
+    {
+      prompt: "animate this",
+      image_path: "/tmp/does-not-exist-99999.png",
+      output_dir: OUTPUT_DIR,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === false, "should fail");
+  assert(result.error.includes("not found"), "should mention file not found");
+});
+
+// ── Live API Test: text-to-video ──
+
+await test("video_gen: text-to-video", async () => {
+  process.stdout.write("  generating video (this takes 1-3 min)...\n");
+  const raw = await videoGen.execute(
+    {
+      prompt:
+        "a slow zoom into a single red rose on a dark background, cinematic",
+      duration: 5,
+      aspect_ratio: "1:1",
+      fps: 24,
+      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(result.output_path.endsWith(".mp4"), "should be .mp4");
+  assert(
+    existsSync(result.output_path),
+    `file should exist: ${result.output_path}`,
+  );
+  assert(result.mode === "text-to-video", "should be text-to-video mode");
+  assert(result.duration === 5, "duration should be 5");
+  assert(
+    result.file_size_bytes > 10000,
+    `file too small: ${result.file_size_bytes}`,
+  );
+
+  process.stdout.write(
+    `  saved: ${result.output_path} (${(result.file_size_bytes / 1024 / 1024).toFixed(1)} MB)\n`,
+  );
+});
+
+// ── 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 video-gen tests passed!\n");

package/opencode/tools/tests/web-search.test.ts

@@ -0,0 +1,106 @@
+import { readFileSync } 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);
+}
+
+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 webSearch = (await import("../web-search.ts")).default;
+
+const ctx = { directory: process.cwd(), worktree: process.cwd() } as Parameters<
+  typeof webSearch.execute
+>[1];
+
+await test("web_search: single query", async () => {
+  const raw = await webSearch.execute(
+    { query: "OpenCode AI coding agent" },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(
+    result.success === true,
+    `expected success, got: ${JSON.stringify(result).slice(0, 200)}`,
+  );
+  assert(Array.isArray(result.results), "results should be array");
+  assert(result.results.length > 0, "should have results");
+  assert(
+    typeof result.results[0].title === "string",
+    "result should have title",
+  );
+  assert(typeof result.results[0].url === "string", "result should have url");
+  assert(
+    typeof result.results[0].score === "number",
+    "result should have score",
+  );
+  assert(typeof result.answer === "string", "should have answer");
+  process.stdout.write(
+    `  ${result.results.length} results, answer: ${(result.answer as string).slice(0, 80)}...\n`,
+  );
+});
+
+await test("web_search: batch query", async () => {
+  const raw = await webSearch.execute(
+    {
+      query: "TypeScript 2025 ||| Bun runtime",
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.batch_mode === true, "should be batch mode");
+  assert(
+    result.results.length === 2,
+    `expected 2 results, got ${result.results.length}`,
+  );
+  assert(result.results[0].query === "TypeScript 2025", "first query mismatch");
+  assert(result.results[1].query === "Bun runtime", "second query mismatch");
+  process.stdout.write(
+    `  query1: ${result.results[0].results.length} results, query2: ${result.results[1].results.length} results\n`,
+  );
+});
+
+await test("web_search: topic param", async () => {
+  const raw = await webSearch.execute(
+    {
+      query: "latest AI news",
+      topic: "news",
+      num_results: 3,
+    },
+    ctx,
+  );
+  const result = JSON.parse(raw as string);
+  assert(result.success === true, "news search should succeed");
+  assert(result.results.length > 0, "should have news results");
+  process.stdout.write(`  ${result.results.length} news results\n`);
+});
+
+await test("web_search: missing API key", async () => {
+  const saved = process.env.TAVILY_API_KEY;
+  delete process.env.TAVILY_API_KEY;
+  const raw = await webSearch.execute({ query: "test" }, ctx);
+  process.env.TAVILY_API_KEY = saved;
+  assert(
+    (raw as string).includes("TAVILY_API_KEY"),
+    "should mention missing key",
+  );
+});
+
+process.stdout.write("\n\nAll web-search tests passed!\n");

package/opencode/tools/video-gen.ts

@@ -0,0 +1,200 @@
+import { tool } from "@opencode-ai/plugin";
+import Replicate from "replicate";
+import { writeFileSync, mkdirSync, readFileSync, existsSync } from "fs";
+import { resolve, extname, dirname } from "path";
+
+const VIDEO_MODEL = "bytedance/seedance-1.5-pro";
+
+interface FileOutput {
+  url(): string | URL;
+  blob(): Promise<Blob>;
+}
+
+function ensureDir(filePath: string): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50);
+}
+
+function loadImageAsBase64(imagePath: string): string {
+  const abs = resolve(imagePath);
+  if (!existsSync(abs)) throw new Error(`Image not found: ${abs}`);
+  const bytes = readFileSync(abs);
+  const ext = extname(abs).toLowerCase();
+  const mimeMap: Record<string, string> = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+  };
+  const mime = mimeMap[ext] ?? "image/png";
+  return `data:${mime};base64,${bytes.toString("base64")}`;
+}
+
+async function outputToBytes(
+  output: unknown,
+): Promise<{ bytes: Buffer; url: string }> {
+  if (output && typeof output === "object" && "url" in output) {
+    const fo = output as FileOutput;
+    const blob = await fo.blob();
+    const urlVal = fo.url();
+    return {
+      bytes: Buffer.from(await blob.arrayBuffer()),
+      url: typeof urlVal === "string" ? urlVal : urlVal.toString(),
+    };
+  }
+
+  if (output && typeof output === "object" && "read" in output) {
+    const readable = output as { read(): Uint8Array };
+    return { bytes: Buffer.from(readable.read()), url: "" };
+  }
+
+  if (typeof output === "string" && output.startsWith("http")) {
+    const res = await fetch(output, { signal: AbortSignal.timeout(120_000) });
+    return { bytes: Buffer.from(await res.arrayBuffer()), url: output };
+  }
+
+  throw new Error("Unexpected model output format");
+}
+
+function friendlyError(e: unknown): string {
+  const msg = e instanceof Error ? e.message : String(e);
+  if (msg.includes("moderation") || msg.includes("safety"))
+    return "Content was blocked by the safety filter. Try a different prompt.";
+  if (msg.includes("429") || msg.includes("Too Many Requests"))
+    return "Rate limited (429). Wait a moment and try again.";
+  if (msg.includes("timeout"))
+    return "The operation timed out. Video generation can take 1-3 minutes — try again.";
+  if (msg.includes("invalid") && msg.includes("image"))
+    return "The input image format is not supported. Use PNG, JPEG, or WebP.";
+  return msg;
+}
+
+export default tool({
+  description:
+    "Generate videos from text prompts or images using ByteDance Seedance 1.5 Pro via Replicate. " +
+    "Supports text-to-video and image-to-video. " +
+    "Options: duration (2-12s), aspect ratio, fps, camera fixed mode, audio generation. " +
+    "Requires REPLICATE_API_TOKEN. You MUST specify output_dir to control where files are saved.",
+  args: {
+    prompt: tool.schema
+      .string()
+      .describe(
+        "Text prompt describing the video. Be specific about motion, camera angle, and scene.",
+      ),
+    image_path: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Path to input image for image-to-video. When provided, the video animates from this image. " +
+          "Supports PNG, JPEG, WebP.",
+      ),
+    duration: tool.schema
+      .number()
+      .optional()
+      .describe("Video duration in seconds (5 or 10). Default: 5"),
+    aspect_ratio: tool.schema
+      .string()
+      .optional()
+      .describe("Aspect ratio: '16:9' (default), '9:16', '1:1', '4:3', '3:4'"),
+    fps: tool.schema
+      .number()
+      .optional()
+      .describe("Frames per second. Default: 24"),
+    camera_fixed: tool.schema
+      .boolean()
+      .optional()
+      .describe("Lock camera in place (no camera motion). Default: false"),
+    generate_audio: tool.schema
+      .boolean()
+      .optional()
+      .describe("Generate audio track for the video. Default: false"),
+    seed: tool.schema
+      .number()
+      .optional()
+      .describe("Random seed for reproducibility"),
+    output_dir: tool.schema
+      .string()
+      .describe(
+        "Output directory where the generated video will be saved. The directory will be created if it doesn't exist. Required.",
+      ),
+  },
+  async execute(args, _context) {
+    const token = process.env.REPLICATE_API_TOKEN;
+    if (!token) return "Error: REPLICATE_API_TOKEN not set.";
+
+    if (!args.prompt) return "Error: 'prompt' is required.";
+    if (!args.output_dir)
+      return "Error: 'output_dir' is required. Specify where to save the output.";
+
+    const replicate = new Replicate({ auth: token });
+    const outputDir = resolve(args.output_dir);
+
+    const rawDuration = args.duration ?? 5;
+    const duration = rawDuration <= 7 ? 5 : 10;
+    const aspectRatio = args.aspect_ratio ?? "16:9";
+    const fps = args.fps ?? 24;
+
+    const input: Record<string, unknown> = {
+      prompt: args.prompt,
+      duration,
+      aspect_ratio: aspectRatio,
+      fps,
+      camera_fixed: args.camera_fixed ?? false,
+      generate_audio: args.generate_audio ?? false,
+    };
+
+    if (args.seed !== undefined) input.seed = Math.floor(args.seed);
+
+    if (args.image_path) {
+      try {
+        input.image = loadImageAsBase64(args.image_path);
+      } catch (e) {
+        return JSON.stringify(
+          { success: false, error: e instanceof Error ? e.message : String(e) },
+          null,
+          2,
+        );
+      }
+    }
+
+    try {
+      const output = await replicate.run(VIDEO_MODEL, { input });
+      const { bytes, url } = await outputToBytes(output);
+
+      const filename = `${slugify(args.prompt)}-${Date.now()}.mp4`;
+      const outPath = resolve(outputDir, filename);
+      ensureDir(outPath);
+      writeFileSync(outPath, bytes);
+
+      return JSON.stringify(
+        {
+          success: true,
+          output_path: outPath,
+          replicate_url: url,
+          prompt: args.prompt,
+          duration,
+          aspect_ratio: aspectRatio,
+          fps,
+          mode: args.image_path ? "image-to-video" : "text-to-video",
+          ...(args.image_path && { input_image: args.image_path }),
+          file_size_bytes: bytes.length,
+        },
+        null,
+        2,
+      );
+    } catch (e) {
+      return JSON.stringify(
+        { success: false, error: friendlyError(e) },
+        null,
+        2,
+      );
+    }
+  },
+});

package/opencode/tools/web-search.ts

@@ -0,0 +1,153 @@
+import { tool } from "@opencode-ai/plugin";
+import { tavily } from "@tavily/core";
+
+interface SearchResult {
+  title: string;
+  url: string;
+  content: string;
+  score: number;
+  publishedDate?: string;
+  rawContent?: string;
+}
+
+interface SearchImage {
+  url: string;
+  description?: string;
+}
+
+interface SearchResponse {
+  query: string;
+  answer?: string;
+  results: SearchResult[];
+  images?: SearchImage[];
+  responseTime?: number;
+}
+
+function formatSingle(query: string, response: SearchResponse): string {
+  return JSON.stringify(
+    {
+      query,
+      success: response.results.length > 0 || !!response.answer,
+      answer: response.answer ?? "",
+      results: response.results.map((r) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.content,
+        score: r.score,
+        published_date: r.publishedDate ?? "",
+      })),
+      images: (response.images ?? []).map((img) => ({
+        url: img.url,
+        description: img.description ?? "",
+      })),
+      response_time_ms: response.responseTime,
+    },
+    null,
+    2,
+  );
+}
+
+export default tool({
+  description:
+    "Search the web for up-to-date information using Tavily. " +
+    "Returns titles, URLs, snippets, relevance scores, images, and a synthesized AI answer. " +
+    "Supports batch queries separated by |||. " +
+    "Use topic='news' for current events, topic='finance' for financial data. " +
+    "After using results, ALWAYS include a Sources section with markdown hyperlinks.",
+  args: {
+    query: tool.schema
+      .string()
+      .describe(
+        "Search query. For batch, separate with ||| (e.g. 'query one ||| query two')",
+      ),
+    num_results: tool.schema
+      .number()
+      .optional()
+      .describe("Results per query (1-20). Default: 5"),
+    topic: tool.schema
+      .string()
+      .optional()
+      .describe("Search topic: 'general' (default), 'news', or 'finance'"),
+    search_depth: tool.schema
+      .string()
+      .optional()
+      .describe(
+        "Search depth: 'basic' (faster, cheaper, default) or 'advanced' (slower, more thorough). Use 'basic' for most queries. Reserve 'advanced' for deep research where comprehensiveness matters.",
+      ),
+  },
+  async execute(args, _context) {
+    const apiKey = process.env.TAVILY_API_KEY;
+    if (!apiKey) return "Error: TAVILY_API_KEY not set.";
+
+    const client = tavily({ apiKey });
+    const maxResults = Math.max(1, Math.min(args.num_results ?? 5, 20));
+    const topic = (args.topic as "general" | "news" | "finance") ?? "general";
+
+    const queries = args.query
+      .split("|||")
+      .map((q) => q.trim())
+      .filter(Boolean);
+    if (queries.length === 0) return "Error: empty query.";
+
+    const searchOne = async (
+      q: string,
+    ): Promise<{ query: string; data?: SearchResponse; error?: string }> => {
+      try {
+        const response = (await client.search(q, {
+          searchDepth: (args.search_depth as "basic" | "advanced") || "basic",
+          topic,
+          maxResults,
+          includeAnswer: true,
+          includeImages: true,
+          includeImageDescriptions: true,
+        })) as unknown as SearchResponse;
+        return { query: q, data: response };
+      } catch (e) {
+        return { query: q, error: String(e) };
+      }
+    };
+
+    const results = await Promise.all(queries.map(searchOne));
+
+    if (queries.length === 1) {
+      const r = results[0]!;
+      if (r.error)
+        return JSON.stringify(
+          { query: r.query, success: false, error: r.error },
+          null,
+          2,
+        );
+      return formatSingle(r.query, r.data!);
+    }
+
+    return JSON.stringify(
+      {
+        batch_mode: true,
+        total_queries: queries.length,
+        results: results.map((r) => {
+          if (r.error)
+            return { query: r.query, success: false, error: r.error };
+          const d = r.data!;
+          return {
+            query: r.query,
+            success: d.results.length > 0 || !!d.answer,
+            answer: d.answer ?? "",
+            results: d.results.map((res) => ({
+              title: res.title,
+              url: res.url,
+              snippet: res.content,
+              score: res.score,
+              published_date: res.publishedDate ?? "",
+            })),
+            images: (d.images ?? []).map((img) => ({
+              url: img.url,
+              description: img.description ?? "",
+            })),
+          };
+        }),
+      },
+      null,
+      2,
+    );
+  },
+});

package/opencode/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@kortix/sandbox",
+  "version": "0.4.1",
+  "description": "Kortix sandbox runtime — kortix-master, opencode config/agents/skills, and dependencies",
+  "private": false,
+  "scripts": {
+    "postinstall": "bash postinstall.sh"
+  },
+  "files": [
+    "kortix-master/src/",
+    "kortix-master/package.json",
+    "kortix-master/tsconfig.json",
+    "opencode/opencode.jsonc",
+    "opencode/ocx.jsonc",
+    "opencode/package.json",
+    "opencode/tsconfig.json",
+    "opencode/agents/",
+    "opencode/commands/",
+    "opencode/tools/",
+    "opencode/skills/",
+    "opencode/plugin/",
+    "opencode/patches/",
+    "opencode/memory.json",
+    "services/",
+    "config/",
+    "postinstall.sh",
+    "patch-agent-browser.js"
+  ],
+  "dependencies": {
+    "@kortix/opencode-ai": "0.2.0"
+  },
+  "peerDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}