@burdenoff/mcp-libs 2026.703.1 → 2026.703.3

package/dist/modules/vibecontrols/index.cjs

@@ -1218,6 +1218,221 @@ var DELETE_AUDIT_LOG = `
     deleteVibeAuditLog(id: $id, reason: $reason)
   }
 `;
+var SANDBOX_FIELDS = `
+  id name description template mode status
+  crdName podName namespace runtimeClass
+  containers { name image ports { containerPort name protocol } env { name value } command args resources { requestsCpu requestsMemory limitsCpu limitsMemory } }
+  containerStatuses { name ready port restartCount }
+  resources { cpuRequest cpuLimit memoryRequest memoryLimit }
+  storage { mode sizeGi mountPath retainOnDelete }
+  network { exposeService internalUrl containerUrls serviceName }
+  ttlSeconds expiresAt metadata errorMessage
+  workspaceId createdBy createdAt updatedAt stoppedAt
+`;
+var LIST_SANDBOXES = `
+  query ListSandboxes($filter: SandboxFilterInput, $pagination: SandboxPaginationInput, $context: ContextInput!) {
+    listSandboxes(filter: $filter, pagination: $pagination, context: $context) {
+      items { ${SANDBOX_FIELDS} }
+      total hasMore
+    }
+  }
+`;
+var GET_SANDBOX = `
+  query GetSandbox($id: ID!, $context: ContextInput!) {
+    getSandbox(id: $id, context: $context) { ${SANDBOX_FIELDS} }
+  }
+`;
+var CREATE_SANDBOX = `
+  mutation CreateSandbox($input: CreateSandboxInput!) {
+    createSandbox(input: $input) { ${SANDBOX_FIELDS} }
+  }
+`;
+var DELETE_SANDBOX = `
+  mutation DeleteSandbox($id: ID!, $context: ContextInput!) {
+    deleteSandbox(id: $id, context: $context)
+  }
+`;
+var STOP_SANDBOX = `
+  mutation StopSandbox($id: ID!, $context: ContextInput!) {
+    stopSandbox(id: $id, context: $context) { ${SANDBOX_FIELDS} }
+  }
+`;
+var START_SANDBOX = `
+  mutation StartSandbox($id: ID!, $context: ContextInput!) {
+    startSandbox(id: $id, context: $context) { ${SANDBOX_FIELDS} }
+  }
+`;
+var EXTEND_SANDBOX_TTL = `
+  mutation ExtendSandboxTTL($id: ID!, $additionalSeconds: Int!, $context: ContextInput!) {
+    extendSandboxTTL(id: $id, additionalSeconds: $additionalSeconds, context: $context) { ${SANDBOX_FIELDS} }
+  }
+`;
+var SANDBOX_TEMPLATE_FIELDS = `
+  id name description template isDefault ttlSeconds
+  containers { name image }
+  resources { cpuRequest cpuLimit memoryRequest memoryLimit }
+  storage { mode sizeGi mountPath retainOnDelete }
+  config metadata allowedImages
+  workspaceId createdBy createdAt updatedAt
+`;
+var LIST_SANDBOX_TEMPLATES = `
+  query ListSandboxTemplates($context: ContextInput!, $template: SandboxTemplate, $pagination: SandboxPaginationInput) {
+    listSandboxTemplates(context: $context, template: $template, pagination: $pagination) {
+      items { ${SANDBOX_TEMPLATE_FIELDS} } total hasMore
+    }
+  }
+`;
+var GET_SANDBOX_TEMPLATE = `
+  query GetSandboxTemplate($context: ContextInput!, $id: ID!) {
+    getSandboxTemplate(context: $context, id: $id) { ${SANDBOX_TEMPLATE_FIELDS} }
+  }
+`;
+var CREATE_SANDBOX_TEMPLATE = `
+  mutation CreateSandboxTemplate($input: CreateSandboxTemplateInput!) {
+    createSandboxTemplate(input: $input) { ${SANDBOX_TEMPLATE_FIELDS} }
+  }
+`;
+var UPDATE_SANDBOX_TEMPLATE = `
+  mutation UpdateSandboxTemplate($input: UpdateSandboxTemplateInput!) {
+    updateSandboxTemplate(input: $input) { ${SANDBOX_TEMPLATE_FIELDS} }
+  }
+`;
+var DELETE_SANDBOX_TEMPLATE = `
+  mutation DeleteSandboxTemplate($context: ContextInput!, $id: ID!) {
+    deleteSandboxTemplate(context: $context, id: $id)
+  }
+`;
+var AVAILABLE_SANDBOX_TAGS = `
+  query AvailableSandboxTags($query: String, $limit: Int) {
+    availableSandboxTags(query: $query, limit: $limit) { id key label color }
+  }
+`;
+var GET_SANDBOX_TAGS = `
+  query GetSandboxTags($input: GetSandboxTagsInput!) {
+    getSandboxTags(input: $input) {
+      id entityId entityType tagId source assignedAt assignedBy
+    }
+  }
+`;
+var CREATE_SANDBOX_TAG = `
+  mutation CreateSandboxTag($input: CreateSandboxTagInput!) {
+    createSandboxTag(input: $input) { id key label color }
+  }
+`;
+var TAG_SANDBOX = `
+  mutation TagSandbox($input: TagSandboxInput!) {
+    tagSandbox(input: $input) {
+      id entityId tagId source assignedAt
+    }
+  }
+`;
+var UNTAG_SANDBOX = `
+  mutation UntagSandbox($input: UntagSandboxInput!) {
+    untagSandbox(input: $input)
+  }
+`;
+var REPLACE_SANDBOX_TAGS = `
+  mutation ReplaceSandboxTags($input: ReplaceSandboxTagsInput!) {
+    replaceSandboxTags(input: $input) {
+      id entityId tagId source assignedAt
+    }
+  }
+`;
+var LIST_ALL_SANDBOXES = `
+  query ListAllSandboxes($context: ContextInput!, $filter: SandboxFilterInput, $pagination: SandboxPaginationInput) {
+    listAllSandboxes(context: $context, filter: $filter, pagination: $pagination) {
+      items { ${SANDBOX_FIELDS} } total hasMore
+    }
+  }
+`;
+var LIST_SANDBOX_NODES = `
+  query ListSandboxNodes($context: ContextInput!) {
+    listSandboxNodes(context: $context) {
+      name status allocatableCpu allocatableMemory sandboxPodCount labels
+    }
+  }
+`;
+var GET_ACTIVE_SANDBOXES = `
+  query GetActiveSandboxes($context: ContextInput!) {
+    getActiveSandboxes(context: $context) { ${SANDBOX_FIELDS} }
+  }
+`;
+var GET_RECENT_SANDBOX_ACTIVITY = `
+  query GetRecentSandboxActivity($context: ContextInput!, $limit: Int) {
+    getRecentSandboxActivity(context: $context, limit: $limit) {
+      items { id action actorId status sandboxName sandboxId createdAt }
+      total
+    }
+  }
+`;
+var GET_SANDBOX_STATS = `
+  query GetSandboxStats($context: ContextInput!) {
+    getSandboxStats(context: $context) {
+      activeSandboxes activeUserSandboxes activeInternalSandboxes
+      totalCreated totalDeleted totalUserCreated totalInternalCreated
+      runningNow provisioningNow stoppedNow expiredCount failedCount
+      totalCpuUsed totalMemoryUsed
+    }
+  }
+`;
+var GET_SANDBOX_LOGS = `
+  query GetSandboxLogs($context: ContextInput!, $id: ID!, $containerName: String!, $tailLines: Int) {
+    getSandboxLogs(context: $context, id: $id, containerName: $containerName, tailLines: $tailLines)
+  }
+`;
+var GET_SANDBOX_CONFIG = `
+  query GetSandboxConfig($context: ContextInput!) {
+    getSandboxConfig(context: $context) {
+      id defaultTtlSeconds maxTtlSeconds allowedTemplates
+      maxConcurrentPerUser maxConcurrentPerWorkspace
+      defaultCpuRequest defaultCpuLimit defaultMemoryRequest defaultMemoryLimit
+      workspaceId updatedAt
+    }
+  }
+`;
+var UPDATE_SANDBOX_CONFIG = `
+  mutation UpdateSandboxConfig($input: UpdateSandboxConfigInput!) {
+    updateSandboxConfig(input: $input) {
+      id defaultTtlSeconds maxTtlSeconds allowedTemplates
+      maxConcurrentPerUser maxConcurrentPerWorkspace
+      defaultCpuRequest defaultCpuLimit defaultMemoryRequest defaultMemoryLimit
+      workspaceId updatedAt
+    }
+  }
+`;
+var SANDBOX_EXPORT_JOB_FIELDS = `
+  id workspaceId format status requestedBy rowCount
+  downloadUrl errorMessage expiresAt createdAt updatedAt
+`;
+var EXPORT_SANDBOXES = `
+  mutation ExportSandboxes($input: ExportSandboxesInput!) {
+    exportSandboxes(input: $input) { ${SANDBOX_EXPORT_JOB_FIELDS} }
+  }
+`;
+var GET_SANDBOX_EXPORT_JOB = `
+  query GetSandboxExportJob($workspaceId: ID!, $jobId: ID!, $context: ContextInput!) {
+    getSandboxExportJob(workspaceId: $workspaceId, jobId: $jobId, context: $context) {
+      ${SANDBOX_EXPORT_JOB_FIELDS}
+    }
+  }
+`;
+var LIST_SANDBOX_EXPORT_JOBS = `
+  query ListSandboxExportJobs($workspaceId: ID!, $context: ContextInput!, $pagination: SandboxPaginationInput) {
+    listSandboxExportJobs(workspaceId: $workspaceId, context: $context, pagination: $pagination) {
+      ${SANDBOX_EXPORT_JOB_FIELDS}
+    }
+  }
+`;
+var GET_SANDBOX_ARTIFACT_BYTES = `
+  query GetSandboxArtifactBytes($input: SandboxArtifactBytesInput!) {
+    getSandboxArtifactBytes(input: $input) { filename mimeType size contentBase64 }
+  }
+`;
+var PROXY_SANDBOX_REQUEST = `
+  mutation ProxySandboxRequest($input: ProxySandboxRequestInput!) {
+    proxySandboxRequest(input: $input) { status body }
+  }
+`;
 var VIBECONTROLS_ANALYTICS = `
   query VibecontrolsAnalytics($input: VibecontrolsAnalyticsInput!) {
     vibecontrolsAnalytics(input: $input) {
@@ -7566,6 +7781,638 @@ function registerTunnelTools(server, ctx, track) {
     }
   );
 }
+var NO_WORKSPACE = "No workspace set. Run the auth workspace_set tool first.";
+var sandboxTemplate = zod.z.enum([
+  "AI_BUILDER",
+  "WORKFLOW_MULTI_NODE",
+  "MISC_SHELL",
+  "CUSTOM",
+  "VIBECONTROLS"
+]);
+var sandboxStatus = zod.z.enum([
+  "PENDING",
+  "PROVISIONING",
+  "RUNNING",
+  "STOPPING",
+  "STOPPED",
+  "EXPIRED",
+  "FAILED"
+]);
+var sandboxMode = zod.z.enum(["DEPLOYMENT", "JOB"]);
+var storageMode = zod.z.enum(["NONE", "EPHEMERAL", "PERSISTENT"]);
+var sandboxExportFormat = zod.z.enum(["CSV", "JSON"]);
+var resourcesSchema = zod.z.object({
+  cpuRequest: zod.z.string().optional(),
+  cpuLimit: zod.z.string().optional(),
+  memoryRequest: zod.z.string().optional(),
+  memoryLimit: zod.z.string().optional()
+});
+var storageSchema = zod.z.object({
+  mode: storageMode.optional().describe("Storage mode: NONE, EPHEMERAL, PERSISTENT"),
+  sizeGi: zod.z.number().optional(),
+  mountPath: zod.z.string().optional(),
+  retainOnDelete: zod.z.boolean().optional()
+});
+var containersSchema = zod.z.array(zod.z.record(zod.z.unknown())).describe(
+  "Container specs: [{ name, image, ports?[{ containerPort, name?, protocol? }], env?[{ name, value }], command?[], args?[], resources?{ requestsCpu, requestsMemory, limitsCpu, limitsMemory } }]"
+);
+function registerSandboxTools(server, ctx, track) {
+  const w = ctx.gql.workspace;
+  const tool = (name, title, description, inputSchema, handler) => {
+    server.registerTool(
+      track(mcpToolName(ctx.productName, name)),
+      { title, description, inputSchema },
+      async (args) => {
+        try {
+          const data = await handler(args);
+          return jsonResult(data);
+        } catch (error) {
+          ctx.logger.error(`vibecontrols_${name} failed`, { error });
+          return errorResult(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    );
+  };
+  const readWorkspaceId = () => {
+    const auth = ctx.auth.read();
+    return auth?.workspaceId;
+  };
+  tool(
+    "sandboxes_list",
+    "List Sandboxes",
+    "List sandboxes in the current workspace with optional template/status filters.",
+    {
+      template: sandboxTemplate.optional(),
+      status: sandboxStatus.optional(),
+      limit: zod.z.number().optional(),
+      offset: zod.z.number().optional(),
+      page: zod.z.number().optional()
+    },
+    async ({ template, status, limit, offset, page }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const filter = {};
+      if (template !== void 0) filter.template = template;
+      if (status !== void 0) filter.status = status;
+      const pagination = {};
+      if (limit !== void 0) pagination.limit = limit;
+      if (offset !== void 0) pagination.offset = offset;
+      if (page !== void 0) pagination.page = page;
+      const data = await w.request(LIST_SANDBOXES, {
+        filter: Object.keys(filter).length ? filter : void 0,
+        pagination: Object.keys(pagination).length ? pagination : void 0,
+        context: { workspaceId }
+      });
+      return data.listSandboxes;
+    }
+  );
+  tool(
+    "sandboxes_get",
+    "Get Sandbox",
+    "Get a sandbox by ID.",
+    { id: zod.z.string().describe("Sandbox ID") },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX, {
+        id,
+        context: { workspaceId }
+      });
+      return data.getSandbox;
+    }
+  );
+  tool(
+    "sandboxes_create",
+    "Create Sandbox",
+    "Create a sandbox from a template + container specs. Workspace context is injected from auth.",
+    {
+      name: zod.z.string(),
+      template: sandboxTemplate,
+      containers: containersSchema,
+      description: zod.z.string().optional(),
+      mode: sandboxMode.optional().describe("Sandbox mode: DEPLOYMENT or JOB"),
+      resources: resourcesSchema.optional(),
+      storage: storageSchema.optional(),
+      ttlSeconds: zod.z.number().optional(),
+      metadata: zod.z.record(zod.z.unknown()).optional(),
+      templateId: zod.z.string().optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(CREATE_SANDBOX, { input });
+      return data.createSandbox;
+    }
+  );
+  tool(
+    "sandboxes_delete",
+    "Delete Sandbox",
+    "Delete a sandbox by ID.",
+    { id: zod.z.string() },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(DELETE_SANDBOX, {
+        id,
+        context: { workspaceId }
+      });
+      return { deleted: data.deleteSandbox, id };
+    }
+  );
+  tool(
+    "sandboxes_start",
+    "Start Sandbox",
+    "Start (resume) a stopped sandbox.",
+    { id: zod.z.string() },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(START_SANDBOX, {
+        id,
+        context: { workspaceId }
+      });
+      return data.startSandbox;
+    }
+  );
+  tool(
+    "sandboxes_stop",
+    "Stop Sandbox",
+    "Stop a running sandbox.",
+    { id: zod.z.string() },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(STOP_SANDBOX, {
+        id,
+        context: { workspaceId }
+      });
+      return data.stopSandbox;
+    }
+  );
+  tool(
+    "sandboxes_extend_ttl",
+    "Extend Sandbox TTL",
+    "Extend a sandbox time-to-live by an additional number of seconds.",
+    {
+      id: zod.z.string(),
+      additionalSeconds: zod.z.number().describe("Seconds to add to the current TTL")
+    },
+    async ({ id, additionalSeconds }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(EXTEND_SANDBOX_TTL, {
+        id,
+        additionalSeconds,
+        context: { workspaceId }
+      });
+      return data.extendSandboxTTL;
+    }
+  );
+  tool(
+    "sandboxes_get_config",
+    "Get Sandbox Config",
+    "Get the sandbox provisioning config (TTL/concurrency/resource defaults) for the workspace.",
+    {},
+    async () => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX_CONFIG, {
+        context: { workspaceId }
+      });
+      return data.getSandboxConfig;
+    }
+  );
+  tool(
+    "sandboxes_update_config",
+    "Update Sandbox Config",
+    "Update the workspace sandbox config. Workspace context is injected from auth.",
+    {
+      defaultTtlSeconds: zod.z.number().optional(),
+      maxTtlSeconds: zod.z.number().optional(),
+      allowedTemplates: zod.z.array(sandboxTemplate).optional(),
+      maxConcurrentPerUser: zod.z.number().optional(),
+      maxConcurrentPerWorkspace: zod.z.number().optional(),
+      defaultCpuRequest: zod.z.string().optional(),
+      defaultCpuLimit: zod.z.string().optional(),
+      defaultMemoryRequest: zod.z.string().optional(),
+      defaultMemoryLimit: zod.z.string().optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(UPDATE_SANDBOX_CONFIG, {
+        input
+      });
+      return data.updateSandboxConfig;
+    }
+  );
+  tool(
+    "sandboxes_get_stats",
+    "Get Sandbox Stats",
+    "Get aggregate sandbox statistics for the workspace.",
+    {},
+    async () => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX_STATS, {
+        context: { workspaceId }
+      });
+      return data.getSandboxStats;
+    }
+  );
+  tool(
+    "sandboxes_get_logs",
+    "Get Sandbox Logs",
+    "Fetch container logs for a sandbox.",
+    {
+      id: zod.z.string(),
+      containerName: zod.z.string(),
+      tailLines: zod.z.number().optional().describe("Number of trailing log lines to return")
+    },
+    async ({ id, containerName, tailLines }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX_LOGS, {
+        context: { workspaceId },
+        id,
+        containerName,
+        tailLines
+      });
+      return data.getSandboxLogs;
+    }
+  );
+  tool(
+    "sandboxes_tags_attach",
+    "Tag Sandbox",
+    "Attach an existing tag to a sandbox.",
+    {
+      sandboxId: zod.z.string(),
+      tagId: zod.z.string(),
+      source: zod.z.string().optional(),
+      validFrom: zod.z.string().optional(),
+      validTo: zod.z.string().optional(),
+      metadata: zod.z.record(zod.z.unknown()).optional()
+    },
+    async (args) => {
+      const data = await w.request(TAG_SANDBOX, { input: args });
+      return data.tagSandbox;
+    }
+  );
+  tool(
+    "sandboxes_tags_detach",
+    "Untag Sandbox",
+    "Remove a tag from a sandbox.",
+    { sandboxId: zod.z.string(), tagId: zod.z.string() },
+    async (args) => {
+      const data = await w.request(UNTAG_SANDBOX, { input: args });
+      return data.untagSandbox;
+    }
+  );
+  tool(
+    "sandboxes_tags_get",
+    "Get Sandbox Tags",
+    "Get all tag assignments for a sandbox.",
+    { sandboxId: zod.z.string() },
+    async (args) => {
+      const data = await w.request(GET_SANDBOX_TAGS, { input: args });
+      return data.getSandboxTags;
+    }
+  );
+  tool(
+    "sandboxes_tags_replace",
+    "Replace Sandbox Tags",
+    "Replace the full set of tags on a sandbox with the provided tag IDs.",
+    { sandboxId: zod.z.string(), tagIds: zod.z.array(zod.z.string()) },
+    async (args) => {
+      const data = await w.request(REPLACE_SANDBOX_TAGS, {
+        input: args
+      });
+      return data.replaceSandboxTags;
+    }
+  );
+  tool(
+    "sandboxes_tags_create",
+    "Create Sandbox Tag",
+    "Create a new sandbox tag definition.",
+    { label: zod.z.string(), color: zod.z.string().optional() },
+    async (args) => {
+      const data = await w.request(CREATE_SANDBOX_TAG, {
+        input: args
+      });
+      return data.createSandboxTag;
+    }
+  );
+  tool(
+    "sandboxes_tags_available",
+    "Available Sandbox Tags",
+    "List available sandbox tags, optionally filtered by a search query.",
+    {
+      query: zod.z.string().optional(),
+      limit: zod.z.number().optional()
+    },
+    async ({ query, limit }) => {
+      const data = await w.request(AVAILABLE_SANDBOX_TAGS, {
+        query,
+        limit
+      });
+      return data.availableSandboxTags;
+    }
+  );
+  tool(
+    "sandboxes_templates_list",
+    "List Sandbox Templates",
+    "List sandbox template configs, optionally filtered by template type.",
+    {
+      template: sandboxTemplate.optional(),
+      limit: zod.z.number().optional(),
+      offset: zod.z.number().optional(),
+      page: zod.z.number().optional()
+    },
+    async ({ template, limit, offset, page }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const pagination = {};
+      if (limit !== void 0) pagination.limit = limit;
+      if (offset !== void 0) pagination.offset = offset;
+      if (page !== void 0) pagination.page = page;
+      const data = await w.request(LIST_SANDBOX_TEMPLATES, {
+        context: { workspaceId },
+        template,
+        pagination: Object.keys(pagination).length ? pagination : void 0
+      });
+      return data.listSandboxTemplates;
+    }
+  );
+  tool(
+    "sandboxes_templates_get",
+    "Get Sandbox Template",
+    "Get a sandbox template config by ID.",
+    { id: zod.z.string() },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX_TEMPLATE, {
+        context: { workspaceId },
+        id
+      });
+      return data.getSandboxTemplate;
+    }
+  );
+  tool(
+    "sandboxes_templates_create",
+    "Create Sandbox Template",
+    "Create a reusable sandbox template config. Workspace context is injected from auth.",
+    {
+      name: zod.z.string(),
+      template: sandboxTemplate,
+      description: zod.z.string().optional(),
+      isDefault: zod.z.boolean().optional(),
+      containers: containersSchema.optional(),
+      resources: resourcesSchema.optional(),
+      storage: storageSchema.optional(),
+      ttlSeconds: zod.z.number().optional(),
+      config: zod.z.record(zod.z.unknown()).optional(),
+      metadata: zod.z.record(zod.z.unknown()).optional(),
+      allowedImages: zod.z.array(zod.z.string()).optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(CREATE_SANDBOX_TEMPLATE, {
+        input
+      });
+      return data.createSandboxTemplate;
+    }
+  );
+  tool(
+    "sandboxes_templates_update",
+    "Update Sandbox Template",
+    "Update an existing sandbox template config. Workspace context is injected from auth.",
+    {
+      id: zod.z.string(),
+      name: zod.z.string().optional(),
+      description: zod.z.string().optional(),
+      isDefault: zod.z.boolean().optional(),
+      containers: containersSchema.optional(),
+      resources: resourcesSchema.optional(),
+      storage: storageSchema.optional(),
+      ttlSeconds: zod.z.number().optional(),
+      config: zod.z.record(zod.z.unknown()).optional(),
+      metadata: zod.z.record(zod.z.unknown()).optional(),
+      allowedImages: zod.z.array(zod.z.string()).optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(UPDATE_SANDBOX_TEMPLATE, {
+        input
+      });
+      return data.updateSandboxTemplate;
+    }
+  );
+  tool(
+    "sandboxes_templates_delete",
+    "Delete Sandbox Template",
+    "Delete a sandbox template config by ID.",
+    { id: zod.z.string() },
+    async ({ id }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(DELETE_SANDBOX_TEMPLATE, {
+        context: { workspaceId },
+        id
+      });
+      return { deleted: data.deleteSandboxTemplate, id };
+    }
+  );
+  tool(
+    "sandboxes_export_create",
+    "Export Sandboxes",
+    "Start an async export job of sandboxes. Workspace + context injected from auth.",
+    {
+      format: sandboxExportFormat.describe("Export format: CSV or JSON"),
+      template: sandboxTemplate.optional().describe("Filter: template type"),
+      status: sandboxStatus.optional().describe("Filter: sandbox status"),
+      includeUsageEvents: zod.z.boolean().optional()
+    },
+    async ({ format, template, status, includeUsageEvents }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const filter = {};
+      if (template !== void 0) filter.template = template;
+      if (status !== void 0) filter.status = status;
+      const input = {
+        workspaceId,
+        format,
+        context: { workspaceId }
+      };
+      if (includeUsageEvents !== void 0) input.includeUsageEvents = includeUsageEvents;
+      if (Object.keys(filter).length) input.filter = filter;
+      const data = await w.request(EXPORT_SANDBOXES, { input });
+      return data.exportSandboxes;
+    }
+  );
+  tool(
+    "sandboxes_export_get",
+    "Get Sandbox Export Job",
+    "Get a sandbox export job by ID.",
+    { jobId: zod.z.string() },
+    async ({ jobId }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_SANDBOX_EXPORT_JOB, {
+        workspaceId,
+        jobId,
+        context: { workspaceId }
+      });
+      return data.getSandboxExportJob;
+    }
+  );
+  tool(
+    "sandboxes_export_list",
+    "List Sandbox Export Jobs",
+    "List sandbox export jobs for the workspace.",
+    {
+      limit: zod.z.number().optional(),
+      offset: zod.z.number().optional(),
+      page: zod.z.number().optional()
+    },
+    async ({ limit, offset, page }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const pagination = {};
+      if (limit !== void 0) pagination.limit = limit;
+      if (offset !== void 0) pagination.offset = offset;
+      if (page !== void 0) pagination.page = page;
+      const data = await w.request(LIST_SANDBOX_EXPORT_JOBS, {
+        workspaceId,
+        context: { workspaceId },
+        pagination: Object.keys(pagination).length ? pagination : void 0
+      });
+      return data.listSandboxExportJobs;
+    }
+  );
+  tool(
+    "sandboxes_export_get_artifact_bytes",
+    "Get Sandbox Artifact Bytes",
+    "Fetch raw bytes (base64) of a file artifact from a sandbox session. Context injected from auth.",
+    {
+      sandboxId: zod.z.string(),
+      sessionId: zod.z.string(),
+      path: zod.z.string().describe("Path of the artifact file inside the sandbox"),
+      onBehalfOfUserId: zod.z.string().optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(
+        GET_SANDBOX_ARTIFACT_BYTES,
+        {
+          input
+        }
+      );
+      return data.getSandboxArtifactBytes;
+    }
+  );
+  tool(
+    "sandboxes_admin_get_active",
+    "Get Active Sandboxes",
+    "Admin: list all currently active sandboxes across the workspace.",
+    {},
+    async () => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(GET_ACTIVE_SANDBOXES, {
+        context: { workspaceId }
+      });
+      return data.getActiveSandboxes;
+    }
+  );
+  tool(
+    "sandboxes_admin_get_recent_activity",
+    "Get Recent Sandbox Activity",
+    "Admin: list recent sandbox activity/audit entries.",
+    { limit: zod.z.number().optional() },
+    async ({ limit }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(
+        GET_RECENT_SANDBOX_ACTIVITY,
+        { context: { workspaceId }, limit }
+      );
+      return data.getRecentSandboxActivity;
+    }
+  );
+  tool(
+    "sandboxes_admin_list_all",
+    "List All Sandboxes",
+    "Admin: list all sandboxes (including other users) with optional filters.",
+    {
+      template: sandboxTemplate.optional(),
+      status: sandboxStatus.optional(),
+      limit: zod.z.number().optional(),
+      offset: zod.z.number().optional(),
+      page: zod.z.number().optional()
+    },
+    async ({ template, status, limit, offset, page }) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const filter = {};
+      if (template !== void 0) filter.template = template;
+      if (status !== void 0) filter.status = status;
+      const pagination = {};
+      if (limit !== void 0) pagination.limit = limit;
+      if (offset !== void 0) pagination.offset = offset;
+      if (page !== void 0) pagination.page = page;
+      const data = await w.request(LIST_ALL_SANDBOXES, {
+        context: { workspaceId },
+        filter: Object.keys(filter).length ? filter : void 0,
+        pagination: Object.keys(pagination).length ? pagination : void 0
+      });
+      return data.listAllSandboxes;
+    }
+  );
+  tool(
+    "sandboxes_admin_list_nodes",
+    "List Sandbox Nodes",
+    "Admin: list cluster nodes available for sandbox scheduling with capacity info.",
+    {},
+    async () => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const data = await w.request(LIST_SANDBOX_NODES, {
+        context: { workspaceId }
+      });
+      return data.listSandboxNodes;
+    }
+  );
+  tool(
+    "sandboxes_proxy_request",
+    "Proxy Sandbox Request",
+    "Proxy an HTTP request into a running sandbox container. Context injected from auth.",
+    {
+      sandboxId: zod.z.string(),
+      method: zod.z.string().describe("HTTP method, e.g. GET, POST, PUT, DELETE"),
+      path: zod.z.string().describe("Request path inside the sandbox"),
+      body: zod.z.record(zod.z.unknown()).optional(),
+      containerName: zod.z.string().optional()
+    },
+    async (args) => {
+      const workspaceId = readWorkspaceId();
+      if (!workspaceId) throw new Error(NO_WORKSPACE);
+      const input = { ...args, context: { workspaceId } };
+      const data = await w.request(PROXY_SANDBOX_REQUEST, {
+        input
+      });
+      return data.proxySandboxRequest;
+    }
+  );
+}
 function registerUISessionTools(server, ctx, track) {
   server.registerTool(
     track(mcpToolName(ctx.productName, "ui_session_get")),
@@ -9474,6 +10321,7 @@ var vibecontrolsModule = {
     registerConfigSettingsTools(server, ctx, trackTool);
     registerWebhookTools(server, ctx, trackTool);
     registerTunnelTools(server, ctx, trackTool);
+    registerSandboxTools(server, ctx, trackTool);
     registerUISessionTools(server, ctx, trackTool);
     registerAiEventTools(server, ctx, trackTool);
     registerTargetTools(server, ctx, trackTool);