feat(github): GitHub repo picker with auto-sync instructions and runtime detection

apps/mesh/package.json

@@ -49,14 +49,20 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
+    "@freestyle-sh/with-bun": "^0.2.12",
+    "@freestyle-sh/with-deno": "^0.0.4",
+    "@freestyle-sh/with-nodejs": "^0.2.9",
     "@inkjs/ui": "^2.0.0",
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@openrouter/ai-sdk-provider": "^2.2.5",
     "@opentelemetry/core": "^2.6.0",
     "@tanstack/react-virtual": "^3.13.21",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
     "ai-sdk-provider-claude-code": "^3.4.4",
     "ai-sdk-provider-codex-cli": "^1.1.0",
     "embedded-postgres": "^18.3.0-beta.16",
+    "freestyle-sandboxes": "^0.1.46",
     "ink": "^6.8.0",
     "kysely": "^0.28.12",
     "nats": "^2.29.3",
@@ -73,13 +79,13 @@
     "@decocms/better-auth": "1.5.17",
     "@decocms/bindings": "workspace:*",
     "@decocms/mcp-utils": "workspace:*",
-    "@jitl/quickjs-wasmfile-release-sync": "0.31.0",
     "@decocms/mesh-sdk": "workspace:*",
     "@decocms/runtime": "workspace:*",
     "@decocms/vite-plugin": "workspace:*",
     "@electric-sql/pglite": "^0.3.15",
     "@floating-ui/react": "^0.27.16",
     "@hookform/resolvers": "^5.2.2",
+    "@jitl/quickjs-wasmfile-release-sync": "0.31.0",
     "@modelcontextprotocol/sdk": "1.27.1",
     "@monaco-editor/react": "^4.7.0",
     "@opentelemetry/api": "^1.9.0",
@@ -136,14 +142,14 @@
     "jose": "^6.0.11",
     "kysely-pglite": "^0.6.1",
     "lucide-react": "^0.468.0",
-    "react-resizable-panels": "^2.1.7",
     "marked": "^15.0.6",
     "mesh-plugin-workflows": "workspace:*",
     "nanoid": "^5.1.6",
     "pg": "^8.16.3",
     "prettier": "^3.4.2",
     "react-hook-form": "^7.66.0",
     "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^2.1.7",
     "react-syntax-highlighter": "^15.6.1",
     "recharts": "^3.6.0",
     "rehype-raw": "^7.0.0",

apps/mesh/src/api/routes/decopilot/built-in-tools/index.ts

@@ -13,6 +13,7 @@ import { createReadToolOutputTool } from "./read-tool-output";
 import { createReadPromptTool } from "./prompts";
 import { createReadResourceTool } from "./resources";
 import { createSandboxTool, type VirtualClient } from "./sandbox";
+import { createVmTools } from "./vm-tools";
 import { createOpenInAgentTool } from "./open-in-agent";
 import { createSubtaskTool } from "./subtask";
 import { userAskTool } from "./user-ask";
@@ -33,6 +34,8 @@ export interface BuiltinToolParams {
   isPlanMode?: boolean;
   toolOutputMap: Map<string, string>;
   passthroughClient: VirtualClient;
+  /** When set, VM file tools replace the sandbox tool */
+  activeVm?: { vmBaseUrl: string } | null;
 }
 
 /**
@@ -56,6 +59,7 @@ function buildAllTools(
     isPlanMode = false,
     toolOutputMap,
     passthroughClient,
+    activeVm,
   } = params;
   const approvalOpts = { isPlanMode };
   const tools: Record<string, unknown> = {
@@ -73,12 +77,6 @@ function buildAllTools(
     read_tool_output: createReadToolOutputTool({
       toolOutputMap,
     }),
-    sandbox: createSandboxTool({
-      passthroughClient,
-      toolOutputMap,
-      needsApproval:
-        toolNeedsApproval(toolApprovalLevel, false, approvalOpts) !== false,
-    }),
     read_resource: createReadResourceTool({
       passthroughClient,
       toolOutputMap,
@@ -99,6 +97,23 @@ function buildAllTools(
       ctx,
     ),
   };
+  // VM tools replace sandbox when a VM is active
+  if (activeVm) {
+    const vmTools = createVmTools({
+      vmBaseUrl: activeVm.vmBaseUrl,
+      toolOutputMap,
+      needsApproval:
+        toolNeedsApproval(toolApprovalLevel, false, approvalOpts) !== false,
+    });
+    Object.assign(tools, vmTools);
+  } else {
+    tools.sandbox = createSandboxTool({
+      passthroughClient,
+      toolOutputMap,
+      needsApproval:
+        toolNeedsApproval(toolApprovalLevel, false, approvalOpts) !== false,
+    });
+  }
   // subtask requires a provider (LLM calls) — skip when provider is null (Claude Code)
   if (provider) {
     tools.subtask = createSubtaskTool(

apps/mesh/src/api/routes/decopilot/built-in-tools/vm-tools.ts

@@ -0,0 +1,272 @@
+/**
+ * VM File Tools
+ *
+ * Built-in decopilot tools that proxy to the in-VM daemon's file operation
+ * endpoints. Registered when a Virtual MCP has an active Freestyle VM,
+ * replacing the QuickJS sandbox tool.
+ */
+
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+import {
+  MAX_RESULT_TOKENS,
+  createOutputPreview,
+  estimateJsonTokens,
+} from "./read-tool-output";
+
+export interface VmToolsParams {
+  readonly vmBaseUrl: string;
+  readonly toolOutputMap: Map<string, string>;
+  readonly needsApproval: boolean;
+}
+
+async function daemonPost(
+  baseUrl: string,
+  endpoint: string,
+  body: Record<string, unknown>,
+): Promise<unknown> {
+  const url = `${baseUrl}/_decopilot_vm/${endpoint}`;
+  const serialized = JSON.stringify(body);
+  // Base64-encode the payload to avoid Cloudflare WAF triggering on
+  // shell commands and other sensitive-looking content in the JSON body.
+  const encoded = btoa(
+    encodeURIComponent(serialized).replace(/%([0-9A-F]{2})/g, (_, p1) =>
+      String.fromCharCode(parseInt(p1, 16)),
+    ),
+  );
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "text/plain" },
+      body: encoded,
+    });
+  } catch {
+    throw new Error(
+      "The server is not running. Ask the user to start it by clicking the server button (left side of the header bar).",
+    );
+  }
+  const rawText = await res.text();
+  let json: unknown;
+  try {
+    json = JSON.parse(rawText);
+  } catch (e) {
+    console.error(
+      "[vm-tools:daemonPost] Failed to parse JSON response endpoint=%s status=%d rawText=%s",
+      endpoint,
+      res.status,
+      rawText.slice(0, 2000),
+    );
+    const statusHint =
+      res.status >= 500
+        ? " (server error)"
+        : res.status === 0
+          ? " (no response)"
+          : "";
+    throw new Error(
+      `Daemon ${endpoint} returned invalid JSON (HTTP ${res.status}${statusHint}): ${rawText.slice(0, 800)}`,
+    );
+  }
+  if (!res.ok) {
+    console.error(
+      "[vm-tools:daemonPost] Non-OK response endpoint=%s status=%d body=%s",
+      endpoint,
+      res.status,
+      rawText.slice(0, 2000),
+    );
+    throw new Error(
+      (json as { error?: string }).error ??
+        `Daemon ${endpoint} failed (${res.status})`,
+    );
+  }
+  return json;
+}
+
+function maybeTruncate(
+  result: unknown,
+  toolOutputMap: Map<string, string>,
+): unknown {
+  let serialized: string;
+  try {
+    serialized =
+      typeof result === "string" ? result : JSON.stringify(result, null, 2);
+  } catch {
+    serialized = String(result);
+  }
+  const tokenCount = estimateJsonTokens(serialized);
+  if (tokenCount > MAX_RESULT_TOKENS) {
+    const toolCallId = `vm_${Date.now()}`;
+    toolOutputMap.set(toolCallId, serialized);
+    const preview = createOutputPreview(serialized);
+    return {
+      truncated: true,
+      message: `Output too large (${tokenCount} tokens). Use read_tool_output with tool_call_id "${toolCallId}" to extract specific data.`,
+      preview,
+    };
+  }
+  return result;
+}
+
+export function createVmTools(params: VmToolsParams) {
+  const { vmBaseUrl, toolOutputMap, needsApproval } = params;
+
+  const read = tool({
+    needsApproval: false,
+    description:
+      "Read a file from the VM's project directory. Returns content with line numbers. " +
+      "Use offset and limit for large files.",
+
+    inputSchema: zodSchema(
+      z.object({
+        path: z
+          .string()
+          .describe("File path relative to project root (e.g. 'src/index.ts')"),
+        offset: z
+          .number()
+          .optional()
+          .describe("Starting line number (1-based, default 1)"),
+        limit: z
+          .number()
+          .optional()
+          .describe("Max lines to return (default 2000)"),
+      }),
+    ),
+    execute: async (input) => {
+      const result = await daemonPost(vmBaseUrl, "read", input);
+      return maybeTruncate(result, toolOutputMap);
+    },
+  });
+
+  const write = tool({
+    needsApproval,
+    description:
+      "Write content to a file in the VM's project directory. " +
+      "Creates parent directories if needed. Overwrites existing files entirely.",
+
+    inputSchema: zodSchema(
+      z.object({
+        path: z.string().describe("File path relative to project root"),
+        content: z.string().describe("The full file content to write"),
+      }),
+    ),
+    execute: async (input) => {
+      return await daemonPost(vmBaseUrl, "write", input);
+    },
+  });
+
+  const edit = tool({
+    needsApproval,
+    description:
+      "Perform exact string replacement in a file in the VM. " +
+      "old_string must be unique in the file unless replace_all is true.",
+
+    inputSchema: zodSchema(
+      z.object({
+        path: z.string().describe("File path relative to project root"),
+        old_string: z.string().describe("The exact text to find and replace"),
+        new_string: z
+          .string()
+          .describe("The replacement text (must differ from old_string)"),
+        replace_all: z
+          .boolean()
+          .optional()
+          .describe("Replace all occurrences (default false)"),
+      }),
+    ),
+    execute: async (input) => {
+      return await daemonPost(vmBaseUrl, "edit", input);
+    },
+  });
+
+  const grep = tool({
+    needsApproval: false,
+    description:
+      "Search file contents in the VM using ripgrep. " +
+      "Supports regex patterns, file type filtering via glob, and context lines.",
+
+    inputSchema: zodSchema(
+      z.object({
+        pattern: z.string().describe("Regex pattern to search for"),
+        path: z
+          .string()
+          .optional()
+          .describe("Directory or file to search in (default: project root)"),
+        glob: z
+          .string()
+          .optional()
+          .describe("Glob pattern to filter files (e.g. '*.ts', '*.{js,jsx}')"),
+        context: z
+          .number()
+          .optional()
+          .describe("Lines of context around matches"),
+        ignore_case: z.boolean().optional().describe("Case-insensitive search"),
+        output_mode: z
+          .enum(["content", "files", "count"])
+          .optional()
+          .describe("Output mode (default: 'files')"),
+        limit: z.number().optional().describe("Max result lines (default 250)"),
+      }),
+    ),
+    execute: async (input) => {
+      console.log(
+        "[vm-tools:grep] inputType=%s input=%s",
+        typeof input,
+        JSON.stringify(input).slice(0, 500),
+      );
+      const result = await daemonPost(vmBaseUrl, "grep", input);
+      return maybeTruncate(result, toolOutputMap);
+    },
+  });
+
+  const glob = tool({
+    needsApproval: false,
+    description:
+      "Find files by name pattern in the VM's project directory. " +
+      "Uses ripgrep for gitignore-aware matching. Returns relative file paths.",
+
+    inputSchema: zodSchema(
+      z.object({
+        pattern: z
+          .string()
+          .describe(
+            "Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.test.tsx')",
+          ),
+        path: z
+          .string()
+          .optional()
+          .describe("Directory to search in (default: project root)"),
+      }),
+    ),
+    execute: async (input) => {
+      const result = await daemonPost(vmBaseUrl, "glob", input);
+      return maybeTruncate(result, toolOutputMap);
+    },
+  });
+
+  const bashSchema = z.object({
+    command: z.string().describe("The bash command to execute"),
+    timeout: z
+      .number()
+      .optional()
+      .describe("Timeout in milliseconds (default 30000, max 120000)"),
+  });
+  const bash = tool({
+    needsApproval,
+    description:
+      "Execute a shell command in the VM's project directory. " +
+      "Working directory is the project root. Timeout default 30s, max 2min.",
+
+    inputSchema: zodSchema(bashSchema),
+    execute: async (input: z.infer<typeof bashSchema>) => {
+      console.log(
+        "[vm-tools:bash] inputType=%s input=%s",
+        typeof input,
+        JSON.stringify(input).slice(0, 500),
+      );
+      const result = await daemonPost(vmBaseUrl, "bash", input);
+      return maybeTruncate(result, toolOutputMap);
+    },
+  });
+
+  return { read, write, edit, grep, glob, bash };
+}