@remixhq/mcp 0.1.21 → 0.1.22

package/dist/server.js

@@ -361,6 +361,19 @@ function assertConfirm(confirm, operation) {
   if (confirm) return;
   throw createPolicyError(`${operation} requires explicit confirmation.`, "Pass confirm=true to run this tool.");
 }
+function truncateText(policy, value) {
+  const originalChars = value.length;
+  if (originalChars <= policy.maxDiffOutputChars) {
+    return { value, truncated: false, originalChars };
+  }
+  return {
+    value: `${value.slice(0, policy.maxDiffOutputChars)}
+
+[truncated ${originalChars - policy.maxDiffOutputChars} chars]`,
+    truncated: true,
+    originalChars
+  };
+}
 
 // src/bootstrap/context.ts
 function createServerContext(params) {
@@ -380,6 +393,8 @@ function createServerContext(params) {
 }
 
 // src/tools/collab/register.ts
+import fs from "fs/promises";
+import path3 from "path";
 import { z as z3 } from "zod";
 
 // src/contracts/collab.ts
@@ -833,7 +848,7 @@ function collectWarnings(value) {
 function collectResultWarnings(value) {
   return collectWarnings(value.warnings);
 }
-function truncateText(value, maxChars) {
+function truncateText2(value, maxChars) {
   if (value.length <= maxChars) {
     return {
       text: value,
@@ -1086,7 +1101,7 @@ async function viewMergeRequest(params) {
     api,
     mrId: params.mrId
   });
-  const truncatedDiff = params.includeUnifiedDiff ? truncateText(review.unifiedDiff, params.diffMaxChars) : null;
+  const truncatedDiff = params.includeUnifiedDiff ? truncateText2(review.unifiedDiff, params.diffMaxChars) : null;
   return {
     data: {
       mergeRequest: review.mergeRequest,
@@ -1780,6 +1795,243 @@ function spawnHistoryImportDetached(repoRoot, options) {
 }
 
 // src/tools/collab/register.ts
+var runtimeEnvScopeSchema = {
+  cwd: z3.string().trim().min(1).optional(),
+  requestId: z3.string().trim().min(1).optional(),
+  projectId: z3.string().trim().min(1).optional(),
+  repoFingerprint: z3.string().trim().min(1).optional(),
+  environment: z3.string().trim().min(1).default("development").optional(),
+  target: z3.string().trim().min(1).default("sandbox").optional()
+};
+var runtimeEnvMetadataSchema = z3.object({
+  id: z3.string(),
+  projectId: z3.string(),
+  repoFingerprint: z3.string(),
+  environment: z3.string(),
+  target: z3.string(),
+  name: z3.string(),
+  inheritancePolicy: z3.string(),
+  createdBy: z3.string(),
+  updatedBy: z3.string().nullable(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  version: z3.number()
+});
+var runtimeEnvListSuccessSchema = makeSuccessSchema(
+  z3.object({
+    items: z3.array(runtimeEnvMetadataSchema)
+  })
+);
+var runtimeEnvWriteSuccessSchema = makeSuccessSchema(
+  z3.object({
+    item: runtimeEnvMetadataSchema.optional(),
+    deleted: z3.string().optional()
+  })
+);
+var runtimeTargetScopeSchema = {
+  cwd: z3.string().trim().min(1).optional(),
+  requestId: z3.string().trim().min(1).optional(),
+  projectId: z3.string().trim().min(1).optional(),
+  repoFingerprint: z3.string().trim().min(1).optional(),
+  environment: z3.string().trim().min(1).default("development").optional()
+};
+var runtimeTargetAppSchema = {
+  cwd: z3.string().trim().min(1).optional(),
+  requestId: z3.string().trim().min(1).optional(),
+  appId: z3.string().trim().min(1).optional(),
+  environment: z3.string().trim().min(1).default("development").optional()
+};
+var runtimeTargetMetadataSchema = z3.object({
+  id: z3.string().optional(),
+  projectId: z3.string().optional(),
+  repoFingerprint: z3.string(),
+  environment: z3.string(),
+  targetId: z3.string(),
+  targetKind: z3.enum(["web", "cli", "mobile", "test", "worker"]),
+  commandKind: z3.enum(["install", "dev", "build", "preview", "test", "custom"]),
+  command: z3.string(),
+  cwd: z3.string(),
+  port: z3.number().nullable(),
+  readiness: z3.record(z3.unknown()).or(z3.object({}).passthrough()),
+  inheritancePolicy: z3.enum(["project_family", "none"]).optional(),
+  enabled: z3.boolean(),
+  version: z3.number().optional()
+});
+var runtimeTargetListSuccessSchema = makeSuccessSchema(z3.object({ items: z3.array(runtimeTargetMetadataSchema) }));
+var runtimeTargetWriteSuccessSchema = makeSuccessSchema(
+  z3.object({
+    item: runtimeTargetMetadataSchema.optional(),
+    items: z3.array(runtimeTargetMetadataSchema).optional(),
+    deleted: z3.string().optional(),
+    result: z3.unknown().optional(),
+    logs: z3.string().optional()
+  })
+);
+var sandboxCommandRunSchema = z3.object({
+  id: z3.string(),
+  appId: z3.string(),
+  actorUserId: z3.string().nullable(),
+  sandboxExternalId: z3.string(),
+  command: z3.string(),
+  cwd: z3.string(),
+  environment: z3.string(),
+  status: z3.enum(["succeeded", "failed", "timed_out"]),
+  exitCode: z3.number().nullable(),
+  stdout: z3.string(),
+  stderr: z3.string(),
+  startedAt: z3.string(),
+  finishedAt: z3.string(),
+  durationMs: z3.number(),
+  metadata: z3.record(z3.unknown()).nullable().optional()
+});
+var sandboxCommandSuccessSchema = makeSuccessSchema(
+  z3.object({
+    result: sandboxCommandRunSchema.optional(),
+    items: z3.array(sandboxCommandRunSchema).optional()
+  })
+);
+var triggerStepInputSchema = z3.object({
+  name: z3.string().trim().min(1).nullable().optional(),
+  type: z3.enum(["shell", "runtime_target"]),
+  command: z3.string().trim().min(1).nullable().optional(),
+  runtimeTargetId: z3.string().trim().min(1).nullable().optional(),
+  cwd: z3.string().trim().min(1).nullable().optional(),
+  timeoutMs: z3.number().int().positive().nullable().optional(),
+  continueOnFailure: z3.boolean().optional(),
+  metadata: z3.record(z3.unknown()).optional()
+});
+var triggerScopeSchema = {
+  cwd: z3.string().trim().min(1).optional(),
+  requestId: z3.string().trim().min(1).optional(),
+  projectId: z3.string().trim().min(1).optional(),
+  repoFingerprint: z3.string().trim().min(1).optional(),
+  environment: z3.string().trim().min(1).default("development").optional(),
+  eventType: z3.string().trim().min(1).optional()
+};
+var triggerAppSchema = {
+  cwd: z3.string().trim().min(1).optional(),
+  requestId: z3.string().trim().min(1).optional(),
+  appId: z3.string().trim().min(1).optional(),
+  environment: z3.string().trim().min(1).default("development").optional()
+};
+var triggerSuccessSchema = makeSuccessSchema(
+  z3.object({
+    result: z3.unknown().optional(),
+    item: z3.unknown().optional(),
+    items: z3.array(z3.unknown()).optional(),
+    deleted: z3.string().optional()
+  })
+);
+var DETECTION_FILES = [
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "bun.lock",
+  "vite.config.ts",
+  "vite.config.js",
+  "next.config.js",
+  "next.config.mjs",
+  "astro.config.mjs",
+  "astro.config.ts"
+];
+async function resolveRuntimeEnvScope(input) {
+  const { repoRoot, binding } = await loadBindingContext(input.cwd);
+  const projectId = input.projectId?.trim() || binding?.projectId || null;
+  const repoFingerprint = input.repoFingerprint?.trim() || binding?.repoFingerprint || null;
+  if (!projectId) throw makeNotBoundError("Project id was not provided and the current repository is not bound to Remix.");
+  if (!repoFingerprint) {
+    throw makeNotBoundError(
+      "Repo fingerprint was not provided and the current repository binding does not include one.",
+      "Pass repoFingerprint explicitly or run from a bound repository."
+    );
+  }
+  return {
+    repoRoot,
+    projectId,
+    scope: {
+      repoFingerprint,
+      environment: input.environment?.trim() || "development",
+      target: input.target?.trim() || "sandbox"
+    }
+  };
+}
+async function resolveRuntimeTargetScope(input) {
+  const { repoRoot, binding } = await loadBindingContext(input.cwd);
+  const projectId = input.projectId?.trim() || binding?.projectId || null;
+  const repoFingerprint = input.repoFingerprint?.trim() || binding?.repoFingerprint || null;
+  if (!projectId) throw makeNotBoundError("Project id was not provided and the current repository is not bound to Remix.");
+  if (!repoFingerprint) {
+    throw makeNotBoundError(
+      "Repo fingerprint was not provided and the current repository binding does not include one.",
+      "Pass repoFingerprint explicitly or run from a bound repository."
+    );
+  }
+  return {
+    repoRoot,
+    projectId,
+    scope: {
+      repoFingerprint,
+      environment: input.environment?.trim() || "development"
+    }
+  };
+}
+async function resolveTriggerScope(input) {
+  const { repoRoot, binding } = await loadBindingContext(input.cwd);
+  const projectId = input.projectId?.trim() || binding?.projectId || null;
+  const repoFingerprint = input.repoFingerprint?.trim() || binding?.repoFingerprint || null;
+  if (!projectId) throw makeNotBoundError("Project id was not provided and the current repository is not bound to Remix.");
+  if (!repoFingerprint) {
+    throw makeNotBoundError(
+      "Repo fingerprint was not provided and the current repository binding does not include one.",
+      "Pass repoFingerprint explicitly or run from a bound repository."
+    );
+  }
+  return {
+    repoRoot,
+    projectId,
+    scope: {
+      repoFingerprint,
+      environment: input.environment?.trim() || "development",
+      eventType: input.eventType?.trim() || void 0
+    }
+  };
+}
+async function resolveRuntimeApp(input) {
+  const { repoRoot, binding } = await loadBindingContext(input.cwd);
+  const appId = input.appId?.trim() || binding?.currentAppId || null;
+  if (!appId) throw makeNotBoundError("App id was not provided and the current repository is not bound to Remix.");
+  return { repoRoot, appId };
+}
+async function readRuntimeDetectionFiles(repoRoot) {
+  const root = repoRoot ?? process.cwd();
+  const files = {};
+  for (const file of DETECTION_FILES) {
+    try {
+      files[file] = await fs.readFile(path3.join(root, file), "utf8");
+    } catch {
+      files[file] = null;
+    }
+  }
+  return files;
+}
+function redactRuntimeLogs(logs) {
+  return logs.replace(/\b([A-Z0-9_]*(?:SECRET|TOKEN|PASSWORD|API_KEY)[A-Z0-9_]*)=([^\s]+)/gi, "$1=[REDACTED]");
+}
+function runtimeStopWarning(result) {
+  if (result.state === "not_stoppable") return "Target is not long-running, so there is no runtime process to stop.";
+  if (result.state === "not_running") return "No running process was found for this target.";
+  if (result.state === "running") return "Stop was requested, but the process still appears to be running.";
+  if (result.stopped === false) return "No runtime process was stopped.";
+  return null;
+}
+function runtimePreviewWarning(result) {
+  if (!result || typeof result !== "object" || !("previewUrl" in result)) return null;
+  const previewUrl = result.previewUrl;
+  if (typeof previewUrl !== "string" || !previewUrl) return null;
+  return "This result includes a temporary E2B preview URL for a running web target. Treat it as runtime state, not a stable or shareable Remix URL.";
+}
 function getAnnotations(access, options) {
   if (access === "read") {
     return {
@@ -1913,6 +2165,12 @@ function registerTool(server, context, params) {
     }
   );
 }
+var runtimeDetectInputSchema = {
+  ...runtimeTargetScopeSchema,
+  appId: z3.string().trim().min(1).optional(),
+  apply: z3.boolean().optional(),
+  confirm: z3.boolean().optional()
+};
 function registerCollabTools(server, context) {
   registerTool(server, context, {
     name: "remix_collab_status",
@@ -1929,6 +2187,628 @@ function registerCollabTools(server, context) {
       });
     }
   });
+  registerTool(server, context, {
+    name: "remix_collab_env_list",
+    description: "List metadata for Remix runtime environment variables for the bound project/repo. Values are never returned.",
+    access: "read",
+    inputSchema: runtimeEnvScopeSchema,
+    outputSchema: runtimeEnvListSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(runtimeEnvScopeSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeEnvScope({ ...input, cwd });
+      const api = await createApiClient();
+      const items = unwrapResponseObject(
+        await api.listProjectRuntimeEnv(projectId, scope),
+        "runtime env list"
+      );
+      return {
+        data: { items },
+        warnings: ["Secret values are write-only and are not returned by this tool."],
+        logContext: { repoRoot }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_env_set",
+    description: "Create or rotate a Remix runtime environment variable. Requires confirm=true. The provided value is sent to the backend Vault path and is never echoed in the result.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeEnvScopeSchema,
+      name: z3.string().trim().min(1),
+      value: z3.string(),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: runtimeEnvWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeEnvScopeSchema,
+        name: z3.string().trim().min(1),
+        value: z3.string(),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Setting a runtime environment variable");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeEnvScope({ ...input, cwd });
+      const api = await createApiClient();
+      const item = unwrapResponseObject(
+        await api.setProjectRuntimeEnv(projectId, input.name, { ...scope, value: input.value }),
+        "runtime env set"
+      );
+      return {
+        data: { item },
+        warnings: ["Secret value accepted but not returned."],
+        logContext: { repoRoot }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_env_delete",
+    description: "Delete a Remix runtime environment variable. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeEnvScopeSchema,
+      name: z3.string().trim().min(1),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: runtimeEnvWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeEnvScopeSchema,
+        name: z3.string().trim().min(1),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Deleting a runtime environment variable");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeEnvScope({ ...input, cwd });
+      const api = await createApiClient();
+      await api.deleteProjectRuntimeEnv(projectId, input.name, scope);
+      return {
+        data: { deleted: input.name },
+        warnings: ["Secret value was not read or returned."],
+        logContext: { repoRoot }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_list",
+    description: "List Remix runtime targets (commands) for the bound project/repo. Returns metadata only; does not execute commands.",
+    access: "read",
+    inputSchema: runtimeTargetScopeSchema,
+    outputSchema: runtimeTargetListSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(runtimeTargetScopeSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeTargetScope({ ...input, cwd });
+      const api = await createApiClient();
+      const items = unwrapResponseObject(
+        await api.listProjectRuntimeTargets(projectId, scope),
+        "runtime target list"
+      );
+      return {
+        data: { items },
+        logContext: { repoRoot }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_detect",
+    description: "Detect runtime install/dev/build targets from repository files or, when appId is set, from the app's E2B workspace. Passing apply=true saves detected targets remotely and requires confirm=true plus remote-write policy.",
+    access: "read",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    inputSchema: runtimeDetectInputSchema,
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(runtimeDetectInputSchema).parse(args);
+      const apply = Boolean(input.apply);
+      if (apply) {
+        assertToolAccess(context.policy, "remote_write");
+        assertConfirm(input.confirm, "Applying detected runtime targets");
+      }
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeTargetScope({ ...input, cwd });
+      const api = await createApiClient();
+      const trimmedAppId = input.appId?.trim();
+      const files = trimmedAppId ? void 0 : await readRuntimeDetectionFiles(repoRoot);
+      const detected = unwrapResponseObject(
+        await api.detectProjectRuntimeTargets(projectId, {
+          ...scope,
+          apply,
+          appId: trimmedAppId,
+          ...files !== void 0 ? { files } : {}
+        }),
+        "runtime targets detect"
+      );
+      const warnings = trimmedAppId ? ["Detection read files from the sandbox workspace for appId.", "Sandbox must exist for sandbox-backed detection."] : apply ? [`Applied ${detected.length} runtime target definitions.`] : ["Dry run only.", "Pass apply=true plus confirm=true to persist detected targets remotely."];
+      return {
+        data: { items: detected },
+        logContext: { repoRoot },
+        warnings
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_set",
+    description: "Create or update a Remix runtime target for install/dev/build/preview/etc. Requires confirm=true. Does not execute the command.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeTargetScopeSchema,
+      targetId: z3.string().trim().min(1),
+      targetKind: z3.enum(["web", "cli", "mobile", "test", "worker"]),
+      commandKind: z3.enum(["install", "dev", "build", "preview", "test", "custom"]),
+      command: z3.string().trim().min(1),
+      targetCwd: z3.string().trim().min(1).optional().default("/home/user/app"),
+      port: z3.number().int().positive().max(65535).nullable().optional(),
+      readiness: z3.record(z3.unknown()).optional(),
+      inheritancePolicy: z3.enum(["project_family", "none"]).optional(),
+      enabled: z3.boolean().optional(),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetScopeSchema,
+        targetId: z3.string().trim().min(1),
+        targetKind: z3.enum(["web", "cli", "mobile", "test", "worker"]),
+        commandKind: z3.enum(["install", "dev", "build", "preview", "test", "custom"]),
+        command: z3.string().trim().min(1),
+        targetCwd: z3.string().trim().min(1).optional().default("/home/user/app"),
+        port: z3.number().int().positive().max(65535).nullable().optional(),
+        readiness: z3.record(z3.unknown()).optional(),
+        inheritancePolicy: z3.enum(["project_family", "none"]).optional(),
+        enabled: z3.boolean().optional(),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Updating a runtime target");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveRuntimeTargetScope({ ...input, cwd });
+      const api = await createApiClient();
+      const item = unwrapResponseObject(
+        await api.setProjectRuntimeTarget(projectId, input.targetId, {
+          ...scope,
+          targetKind: input.targetKind,
+          commandKind: input.commandKind,
+          command: input.command,
+          cwd: input.targetCwd?.trim() ?? "/home/user/app",
+          port: input.port ?? null,
+          ...input.readiness !== void 0 ? { readiness: input.readiness } : {},
+          inheritancePolicy: input.inheritancePolicy ?? "project_family",
+          enabled: input.enabled ?? true
+        }),
+        "runtime target set"
+      );
+      return { data: { item }, warnings: ["Command definitions are persisted but not executed by this tool."], logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_run",
+    description: "Run a Remix runtime target in the app's E2B sandbox (explicit execution only \u2014 not used by collaboration recording). Running web targets with ports may return a temporary E2B preview URL. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      targetId: z3.string().trim().min(1),
+      forceInstall: z3.boolean().optional(),
+      forceRestart: z3.boolean().optional(),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        targetId: z3.string().trim().min(1),
+        forceInstall: z3.boolean().optional(),
+        forceRestart: z3.boolean().optional(),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Running a runtime target in sandbox");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const result = unwrapResponseObject(
+        await api.runAppRuntimeTarget(appId, input.targetId, {
+          environment: input.environment?.trim() || "development",
+          forceInstall: Boolean(input.forceInstall),
+          forceRestart: Boolean(input.forceRestart)
+        }),
+        "runtime target run"
+      );
+      const previewWarning = runtimePreviewWarning(result);
+      return {
+        data: { result },
+        warnings: [
+          "Process output may include sensitive values; inspect logs separately with remix_collab_runtime_logs.",
+          ...previewWarning ? [previewWarning] : []
+        ],
+        logContext: { repoRoot, appId }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_logs",
+    description: "Tail recent Remix runtime stdout/stderr logs for any target. Long-running targets return live logs; one-shot targets return the latest completed run. Output is lightly redacted; secret values must still be handled carefully.",
+    access: "read",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      targetId: z3.string().trim().min(1),
+      limit: z3.number().int().positive().max(2e4).optional()
+    },
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        targetId: z3.string().trim().min(1),
+        limit: z3.number().int().positive().max(2e4).optional()
+      }).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const bundle = unwrapResponseObject(
+        await api.getAppRuntimeTargetLogs(appId, input.targetId, {
+          environment: input.environment?.trim() || "development",
+          limit: input.limit
+        }),
+        "runtime target logs"
+      );
+      const logs = truncateText(context.policy, redactRuntimeLogs(bundle.logs ?? ""));
+      return {
+        data: {
+          logs: logs.value
+        },
+        warnings: logs.truncated ? [
+          "Log tail was truncated to fit MCP output limits.",
+          "Values resembling tokens/passwords were redacted heuristically.",
+          "One-shot targets show latest completed-run logs; long-running targets show live sandbox logs."
+        ] : [
+          "Values resembling tokens/passwords were redacted heuristically.",
+          "One-shot targets show latest completed-run logs; long-running targets show live sandbox logs."
+        ],
+        logContext: { repoRoot, appId }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_status",
+    description: "Read process/readiness status plus latest run metadata for a Remix runtime target. Running web targets with ports may include a temporary E2B preview URL. This is separate from app lifecycle status and does not execute or stop commands.",
+    access: "read",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      targetId: z3.string().trim().min(1)
+    },
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        targetId: z3.string().trim().min(1)
+      }).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const result = unwrapResponseObject(
+        await api.getAppRuntimeTargetStatus(appId, input.targetId, {
+          environment: input.environment?.trim() || "development"
+        }),
+        "runtime target status"
+      );
+      const previewWarning = runtimePreviewWarning(result);
+      return { data: { result }, warnings: previewWarning ? [previewWarning] : void 0, logContext: { repoRoot, appId } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_runtime_stop",
+    description: "Stop a long-running Remix runtime target process in E2B. Non-long-running targets report not_stoppable. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      targetId: z3.string().trim().min(1),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: runtimeTargetWriteSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        targetId: z3.string().trim().min(1),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Stopping a runtime target process");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const result = unwrapResponseObject(
+        await api.stopAppRuntimeTarget(appId, input.targetId, { environment: input.environment?.trim() || "development" }),
+        "runtime target stop"
+      );
+      const warning = runtimeStopWarning(result);
+      return { data: { result }, warnings: warning ? [warning] : void 0, logContext: { repoRoot, appId } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_sandbox_command_run",
+    description: "Run a one-shot shell command inside an app's E2B sandbox. This can mutate sandbox state and dirty the repo. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      command: z3.string().trim().min(1),
+      commandCwd: z3.string().trim().min(1).optional().default("/home/user/app"),
+      timeoutMs: z3.number().int().min(1e3).max(6e5).optional(),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: sandboxCommandSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        command: z3.string().trim().min(1),
+        commandCwd: z3.string().trim().min(1).optional().default("/home/user/app"),
+        timeoutMs: z3.number().int().min(1e3).max(6e5).optional(),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Running an arbitrary sandbox command");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const run = unwrapResponseObject(
+        await api.runAppSandboxCommand(appId, {
+          command: input.command,
+          cwd: input.commandCwd?.trim() || "/home/user/app",
+          timeoutMs: input.timeoutMs ?? 12e4,
+          environment: input.environment?.trim() || "development"
+        }),
+        "sandbox command run"
+      );
+      const stdout = truncateText(context.policy, typeof run.stdout === "string" ? run.stdout : "");
+      const stderr = truncateText(context.policy, typeof run.stderr === "string" ? run.stderr : "");
+      const result = { ...run, stdout: stdout.value, stderr: stderr.value };
+      return {
+        data: { result },
+        warnings: [
+          "Sandbox commands can mutate files, install tools, change runtime state, and dirty the app repository.",
+          "Returned stdout/stderr are redacted by the backend before persistence.",
+          ...stdout.truncated || stderr.truncated ? ["Command output was truncated to fit MCP output limits."] : []
+        ],
+        logContext: { repoRoot, appId }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_sandbox_command_history",
+    description: "List recent one-shot sandbox commands for an app. Output is redacted and may be truncated.",
+    access: "read",
+    inputSchema: {
+      ...runtimeTargetAppSchema,
+      limit: z3.number().int().positive().max(100).optional()
+    },
+    outputSchema: sandboxCommandSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...runtimeTargetAppSchema,
+        limit: z3.number().int().positive().max(100).optional()
+      }).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const history = unwrapResponseObject(
+        await api.listAppSandboxCommandHistory(appId, { limit: input.limit ?? 20 }),
+        "sandbox command history"
+      );
+      const items = (history.items ?? []).map((item) => {
+        const stdout = truncateText(context.policy, typeof item.stdout === "string" ? item.stdout : "");
+        const stderr = truncateText(context.policy, typeof item.stderr === "string" ? item.stderr : "");
+        return { ...item, stdout: stdout.value, stderr: stderr.value };
+      });
+      return {
+        data: { items },
+        warnings: ["Sandbox command history contains redacted command output. Large outputs may be truncated for MCP."],
+        logContext: { repoRoot, appId }
+      };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_events",
+    description: "List supported Remix project trigger events and whether each event is currently wired.",
+    access: "read",
+    inputSchema: triggerScopeSchema,
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(triggerScopeSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId } = await resolveTriggerScope({ ...input, cwd, repoFingerprint: input.repoFingerprint ?? "events" });
+      const api = await createApiClient();
+      const items = unwrapResponseObject(
+        await api.listProjectTriggerEvents(projectId),
+        "trigger events"
+      );
+      return { data: { items }, logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_list",
+    description: "List Remix project triggers for the bound project/repo/environment.",
+    access: "read",
+    inputSchema: triggerScopeSchema,
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object(triggerScopeSchema).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveTriggerScope({ ...input, cwd });
+      const api = await createApiClient();
+      const items = unwrapResponseObject(
+        await api.listProjectTriggers(projectId, scope),
+        "trigger list"
+      );
+      return { data: { items }, logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_create",
+    description: "Create a Remix project trigger. Requires confirm=true because future events may execute configured commands.",
+    access: "remote_write",
+    inputSchema: {
+      ...triggerScopeSchema,
+      name: z3.string().trim().min(1),
+      description: z3.string().nullable().optional(),
+      mode: z3.enum(["blocking", "async"]).optional(),
+      priority: z3.number().int().optional(),
+      enabled: z3.boolean().optional(),
+      steps: z3.array(triggerStepInputSchema).default([]),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...triggerScopeSchema,
+        name: z3.string().trim().min(1),
+        description: z3.string().nullable().optional(),
+        mode: z3.enum(["blocking", "async"]).optional(),
+        priority: z3.number().int().optional(),
+        enabled: z3.boolean().optional(),
+        steps: z3.array(triggerStepInputSchema).default([]),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Creating a trigger");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId, scope } = await resolveTriggerScope({ ...input, cwd });
+      if (!scope.eventType) throw makeNotBoundError("eventType is required to create a trigger.");
+      const api = await createApiClient();
+      const item = unwrapResponseObject(
+        await api.createProjectTrigger(projectId, {
+          ...scope,
+          eventType: scope.eventType,
+          name: input.name,
+          description: input.description ?? null,
+          mode: input.mode ?? "async",
+          priority: input.priority ?? 100,
+          enabled: input.enabled ?? true,
+          steps: input.steps
+        }),
+        "trigger create"
+      );
+      return { data: { item }, logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_update",
+    description: "Update trigger metadata. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: {
+      ...triggerScopeSchema,
+      triggerId: z3.string().trim().min(1),
+      name: z3.string().trim().min(1).optional(),
+      enabled: z3.boolean().optional(),
+      mode: z3.enum(["blocking", "async"]).optional(),
+      priority: z3.number().int().optional(),
+      confirm: z3.boolean().optional()
+    },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({
+        ...triggerScopeSchema,
+        triggerId: z3.string().trim().min(1),
+        name: z3.string().trim().min(1).optional(),
+        enabled: z3.boolean().optional(),
+        mode: z3.enum(["blocking", "async"]).optional(),
+        priority: z3.number().int().optional(),
+        confirm: z3.boolean().optional()
+      }).parse(args);
+      assertConfirm(input.confirm, "Updating a trigger");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId } = await resolveTriggerScope({ ...input, cwd });
+      const api = await createApiClient();
+      const item = unwrapResponseObject(
+        await api.updateProjectTrigger(projectId, input.triggerId, {
+          name: input.name,
+          enabled: input.enabled,
+          mode: input.mode,
+          priority: input.priority
+        }),
+        "trigger update"
+      );
+      return { data: { item }, logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_delete",
+    description: "Delete a trigger. Requires confirm=true.",
+    access: "remote_write",
+    inputSchema: { ...triggerScopeSchema, triggerId: z3.string().trim().min(1), confirm: z3.boolean().optional() },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({ ...triggerScopeSchema, triggerId: z3.string().trim().min(1), confirm: z3.boolean().optional() }).parse(args);
+      assertConfirm(input.confirm, "Deleting a trigger");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId } = await resolveTriggerScope({ ...input, cwd });
+      const api = await createApiClient();
+      await api.deleteProjectTrigger(projectId, input.triggerId);
+      return { data: { deleted: input.triggerId }, logContext: { repoRoot } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_run",
+    description: "Manually run one trigger for the bound app. Requires confirm=true because it may execute commands.",
+    access: "remote_write",
+    inputSchema: { ...triggerAppSchema, triggerId: z3.string().trim().min(1), confirm: z3.boolean().optional() },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({ ...triggerAppSchema, triggerId: z3.string().trim().min(1), confirm: z3.boolean().optional() }).parse(args);
+      assertConfirm(input.confirm, "Running a trigger");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const result = unwrapResponseObject(
+        await api.runAppTrigger(appId, input.triggerId, { eventSource: "mcp", eventContext: {} }),
+        "trigger run"
+      );
+      return { data: { result }, logContext: { repoRoot, appId } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_triggers_run_event",
+    description: "Manually run all triggers resolved for one event. Requires confirm=true because it may execute commands.",
+    access: "remote_write",
+    inputSchema: { ...triggerAppSchema, eventType: z3.string().trim().min(1), confirm: z3.boolean().optional() },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({ ...triggerAppSchema, eventType: z3.string().trim().min(1), confirm: z3.boolean().optional() }).parse(args);
+      assertConfirm(input.confirm, "Running trigger event");
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, appId } = await resolveRuntimeApp({ ...input, cwd });
+      const api = await createApiClient();
+      const result = unwrapResponseObject(
+        await api.runAppTriggerEvent(appId, {
+          eventType: input.eventType,
+          eventSource: "mcp",
+          eventContext: {},
+          environment: input.environment?.trim() || "development"
+        }),
+        "trigger run event"
+      );
+      return { data: { result }, logContext: { repoRoot, appId } };
+    }
+  });
+  registerTool(server, context, {
+    name: "remix_collab_trigger_runs",
+    description: "List trigger run history for the bound project.",
+    access: "read",
+    inputSchema: { ...triggerScopeSchema, limit: z3.number().int().positive().max(100).optional(), appId: z3.string().trim().min(1).optional() },
+    outputSchema: triggerSuccessSchema,
+    run: async (args) => {
+      const input = z3.object({ ...triggerScopeSchema, limit: z3.number().int().positive().max(100).optional(), appId: z3.string().trim().min(1).optional() }).parse(args);
+      const cwd = resolvePolicyCwd(context.policy, input.cwd);
+      const { repoRoot, projectId } = await resolveTriggerScope({ ...input, cwd });
+      const api = await createApiClient();
+      const items = unwrapResponseObject(
+        await api.listProjectTriggerRuns(projectId, {
+          limit: input.limit ?? 20,
+          eventType: input.eventType,
+          appId: input.appId
+        }),
+        "trigger runs"
+      );
+      return { data: { items }, logContext: { repoRoot } };
+    }
+  });
   registerTool(server, context, {
     name: "remix_collab_init",
     description: "Import the current repository into Remix and write the local binding file. Synchronous: by the time this tool resolves, the local binding file AND the local Remix baseline are both on disk, so automatic hook recording can capture subsequent completed turns. Brand-new init on the default branch typically takes ~10s; non-default-branch init can take 30-90s while the server provisions a feature lane. The result includes `reused: boolean` (false for a brand-new app, true if a binding already existed) plus the canonical app/project identifiers and the dashboard URL. Use forceNew=true only when intentionally creating a new canonical family from scratch in a previously-bound repo; do NOT use forceNew as a retry mechanism for a failed init \u2014 it creates orphan backend apps and triggers canonical-family ambiguity errors on subsequent inits in this directory.",