@remixhq/mcp 0.1.14 → 0.1.16

package/dist/cli.js

@@ -499,14 +499,6 @@ var recordTurnInputSchema = {
   allowBranchMismatch: z2.boolean().optional(),
   idempotencyKey: z2.string().trim().min(1).optional()
 };
-var finalizeTurnInputSchema = {
-  ...commonRequestFieldsSchema,
-  prompt: z2.string().trim().min(1),
-  assistantResponse: z2.string().trim().min(1),
-  sync: z2.boolean().optional(),
-  allowBranchMismatch: z2.boolean().optional(),
-  idempotencyKey: z2.string().trim().min(1).optional()
-};
 var previewInputSchema = {
   ...commonRequestFieldsSchema
 };
@@ -676,17 +668,6 @@ var addDataSchema = z2.object({
   changeStep: genericRecordSchema
 });
 var recordTurnDataSchema = genericRecordSchema;
-var finalizeTurnDataSchema = z2.object({
-  mode: z2.enum(["changed_turn", "no_diff_turn"]),
-  idempotencyKey: z2.string().min(1),
-  queued: z2.boolean(),
-  jobId: z2.string().nullable(),
-  repoState: z2.string().nullable(),
-  changeStep: genericRecordSchema.nullable(),
-  collabTurn: genericRecordSchema.nullable(),
-  autoSync: genericRecordSchema.nullable(),
-  warnings: z2.array(z2.string())
-});
 var drainFinalizeQueueDataSchema = z2.object({
   processed: z2.number().int().nonnegative(),
   results: z2.array(genericRecordSchema)
@@ -766,7 +747,6 @@ var remixSuccessSchema = makeSuccessSchema(remixDataSchema);
 var checkoutSuccessSchema = makeSuccessSchema(checkoutDataSchema);
 var addSuccessSchema = makeSuccessSchema(addDataSchema);
 var recordTurnSuccessSchema = makeSuccessSchema(recordTurnDataSchema);
-var finalizeTurnSuccessSchema = makeSuccessSchema(finalizeTurnDataSchema);
 var drainFinalizeQueueSuccessSchema = makeSuccessSchema(drainFinalizeQueueDataSchema);
 var syncSuccessSchema = makeSuccessSchema(syncDataSchema);
 var reAnchorSuccessSchema = makeSuccessSchema(reAnchorDataSchema);
@@ -787,13 +767,11 @@ var accessDebugSuccessSchema = makeSuccessSchema(accessDebugDataSchema);
 var updateMemberRoleSuccessSchema = makeSuccessSchema(updateMemberRoleDataSchema);
 
 // src/domain/coreAdapter.ts
-import { spawn } from "child_process";
 import {
   collabList as coreCollabList,
   collabListMembers as coreCollabListMembers,
   collabUpdateMemberRole as coreCollabUpdateMemberRole,
   drainPendingFinalizeQueue as coreDrainPendingFinalizeQueue,
-  collabFinalizeTurn as coreCollabFinalizeTurn,
   collabApprove as coreCollabApprove,
   collabCheckout as coreCollabCheckout,
   collabListMergeRequests as coreCollabListMergeRequests,
@@ -832,17 +810,17 @@ function getRecommendedNextActions(status) {
       return ["Run remix_collab_sync_preview, then remix_collab_sync_apply if the preview is acceptable. This pulls the server delta into the local working tree without rewriting local git history."];
     case "re_anchor":
       return [
-        "Run remix_collab_re_anchor_preview, then remix_collab_re_anchor_apply. This seeds a local Remix baseline. It is required because no local baseline exists for this lane yet (fresh clone, deleted .remix/ state, or first init didn't seed) \u2014 not because of any specific git operation. After it succeeds, normal recording (remix_collab_finalize_turn) becomes available."
+        "Run remix_collab_re_anchor_preview, then remix_collab_re_anchor_apply. This seeds a local Remix baseline. It is required because no local baseline exists for this lane yet (fresh clone, deleted .remix/ state, or first init didn't seed) \u2014 not because of any specific git operation. After it succeeds, automatic hook recording can capture completed turns."
       ];
     case "record":
       return [
-        "Run remix_collab_finalize_turn to capture the local boundary delta. This is the catch-all for any local content change since the last recorded turn, regardless of whether the change came from agent edits, manual user edits, git commit, git pull, git merge, git rebase, or git reset."
+        "No MCP recording tool is required. Automatic hook finalization will capture the local boundary at the end of the completed turn; this covers agent edits, manual user edits, git commit, git pull, git merge, git rebase, and git reset."
       ];
     case "reconcile":
       return ["Run remix_collab_reconcile_preview before attempting remix_collab_reconcile_apply. Reconcile applies only when both the local workspace and the server lane changed since the last agreed baseline."];
     case "await_finalize":
       return [
-        "Run remix_collab_drain_finalize_queue before merge-related or recovery flows. finalize_turn is queued only until the local finalize queue is drained."
+        "Run remix_collab_drain_finalize_queue before merge-related or recovery flows. Hook recording is queued until the local finalize queue is drained."
       ];
     case "review_queue":
       return ["Run remix_collab_review_queue to inspect reviewable merge requests instead of using local git merge flows."];
@@ -877,17 +855,6 @@ function truncateText(value, maxChars) {
     originalChars: value.length
   };
 }
-function spawnFinalizeQueueDrainer() {
-  const entrypoint = process.argv[1];
-  if (!entrypoint) return false;
-  const child = spawn(process.execPath, [...process.execArgv, entrypoint, "--drain-finalize-queue"], {
-    detached: true,
-    stdio: "ignore",
-    env: process.env
-  });
-  child.unref();
-  return true;
-}
 async function drainBeforeMutation(api) {
   const results = await coreDrainPendingFinalizeQueue({ api });
   return results.flatMap((result) => collectResultWarnings(result));
@@ -930,7 +897,7 @@ async function initCollab(params) {
     data: syncResult,
     warnings: collectResultWarnings(result),
     recommendedNextActions: syncResult.baselineStatus === "requires_re_anchor" ? [
-      "This checkout has no local Remix baseline yet. Run remix_collab_re_anchor_preview, then remix_collab_re_anchor_apply to seed one. After it succeeds, normal recording (remix_collab_finalize_turn) becomes available."
+      "This checkout has no local Remix baseline yet. Run remix_collab_re_anchor_preview, then remix_collab_re_anchor_apply to seed one. After it succeeds, automatic hook recording can capture completed turns."
     ] : syncResult.baselineStatus === "requires_sync" ? [
       "Run remix_collab_sync_preview, then remix_collab_sync_apply to pull the server delta and create the first local baseline for this checkout."
     ] : ["Run remix_collab_status to inspect sync, reconcile, and merge-request readiness before mutating bound-repo state."],
@@ -995,36 +962,6 @@ async function checkoutCollab(params) {
     }
   };
 }
-async function finalizeCollabTurn(params) {
-  const api = await createCollabApiClient();
-  const repoRoot = await findGitRoot(params.cwd);
-  const result = await coreCollabFinalizeTurn({
-    api,
-    cwd: params.cwd,
-    prompt: params.prompt,
-    assistantResponse: params.assistantResponse,
-    sync: params.sync,
-    allowBranchMismatch: params.allowBranchMismatch ?? false,
-    idempotencyKey: params.idempotencyKey ?? null,
-    actor: params.agent,
-    awaitingUsageDeadlineMs: params.awaitingUsageDeadlineMs ?? null
-  });
-  const hasAwaitingDeadline = typeof params.awaitingUsageDeadlineMs === "number" && params.awaitingUsageDeadlineMs > 0;
-  if (result.queued && !hasAwaitingDeadline) {
-    if (!spawnFinalizeQueueDrainer()) {
-      await coreDrainPendingFinalizeQueue({ api });
-    }
-  }
-  return {
-    data: result,
-    warnings: result.warnings,
-    recommendedNextActions: result.queued ? ["Run remix_collab_drain_finalize_queue before merge-related flows if you need this queued turn recorded immediately."] : [],
-    logContext: {
-      repoRoot,
-      appId: result.changeStep?.appId ?? result.collabTurn?.appId ?? null
-    }
-  };
-}
 async function drainFinalizeQueue(params) {
   const api = await createCollabApiClient();
   const repoRoot = await findGitRoot(params.cwd);
@@ -1075,7 +1012,7 @@ async function reAnchor(params) {
     data: result,
     warnings: collectWarnings(result.warnings),
     recommendedNextActions: params.dryRun ? [
-      "Run remix_collab_re_anchor_apply with confirm=true to seed a local Remix baseline for this checkout. Re-anchor is for missing-baseline cases only and does not replace remix_collab_finalize_turn for ordinary local content changes."
+      "Run remix_collab_re_anchor_apply with confirm=true to seed a local Remix baseline for this checkout. Re-anchor is for missing-baseline cases only and does not replace automatic hook recording for ordinary local content changes."
     ] : [],
     logContext: {
       repoRoot: result.repoRoot,
@@ -1807,7 +1744,7 @@ async function accessDebug(params) {
 }
 
 // src/tools/collab/autoSpawnHistoryImport.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { existsSync, mkdirSync, openSync } from "fs";
 import path2 from "path";
 var MARKER_REL_PATH = path2.join(".remix", ".history-imported");
@@ -1828,7 +1765,7 @@ function spawnHistoryImportDetached(repoRoot) {
   const logPath = path2.join(repoRoot, LOG_REL_PATH);
   const out = openSync(logPath, "a");
   const err = openSync(logPath, "a");
-  const child = spawn2(
+  const child = spawn(
     "remix",
     [
       "history",
@@ -1971,7 +1908,7 @@ function registerCollabTools(server, context) {
   });
   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 the very next call to remix_collab_finalize_turn will succeed. 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.",
+    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.",
     access: "remote_write",
     inputSchema: initInputSchema,
     outputSchema: initSuccessSchema,
@@ -2055,31 +1992,9 @@ function registerCollabTools(server, context) {
       });
     }
   });
-  registerTool(server, context, {
-    name: "remix_collab_finalize_turn",
-    description: "Primary turn recorder for the current bound repository. Required: call this exactly once before the final response on every turn that touched a Remix-bound repo. Captures the current boundary locally and queues remote processing. Queued only: no remote change step exists yet until the finalize queue drains. Runtime exception: if this turn's context contains a [Remix runtime status] system note from the Remix UserPromptSubmit hook stating that the Stop hook will record this turn automatically, do NOT call this tool \u2014 the runtime is recording it on your behalf and a manual call would create a duplicate record. The runtime note is the only sanctioned override; trivial prompts, error states, and ambiguity all still require this call.",
-    access: "local_write",
-    inputSchema: finalizeTurnInputSchema,
-    outputSchema: finalizeTurnSuccessSchema,
-    annotations: getAnnotations("local_write", { idempotent: true }),
-    run: async (args) => {
-      const input = z3.object(finalizeTurnInputSchema).parse(args);
-      const cwd = resolvePolicyCwd(context.policy, input.cwd);
-      return finalizeCollabTurn({
-        cwd,
-        prompt: input.prompt,
-        assistantResponse: input.assistantResponse,
-        sync: input.sync,
-        allowBranchMismatch: input.allowBranchMismatch ?? false,
-        idempotencyKey: input.idempotencyKey,
-        agent: context.agentMetadata,
-        awaitingUsageDeadlineMs: 3e4
-      });
-    }
-  });
   registerTool(server, context, {
     name: "remix_collab_drain_finalize_queue",
-    description: "Drain the local finalize queue and record queued finalize_turn jobs immediately. NOT required as a precondition for `remix_collab_request_merge` or `remix_collab_reconcile_apply` \u2014 those tools drain the queue internally before they run. Useful only for explicit recovery flows (e.g. status reports `await_finalize` and you want to flush before re-checking). Runtime exception: if this turn's context contains a [Remix runtime status] system note from the Remix UserPromptSubmit hook, the runtime drains the queue automatically in the background; do NOT call this tool unless an explicit recovery flow requires it.",
+    description: "Drain the local finalize queue and record queued hook-finalize jobs immediately. NOT required as a precondition for `remix_collab_request_merge` or `remix_collab_reconcile_apply` \u2014 those tools drain the queue internally before they run. Useful only for explicit recovery flows (e.g. status reports `await_finalize` and you want to flush before re-checking). Runtime exception: if this turn's context contains a [Remix runtime status] system note from the Remix UserPromptSubmit hook, the runtime drains the queue automatically in the background; do NOT call this tool unless an explicit recovery flow requires it.",
     access: "local_write",
     inputSchema: drainFinalizeQueueInputSchema,
     outputSchema: drainFinalizeQueueSuccessSchema,
@@ -2117,7 +2032,7 @@ function registerCollabTools(server, context) {
   });
   registerTool(server, context, {
     name: "remix_collab_re_anchor_preview",
-    description: "Preview whether this checkout needs a fresh local Remix baseline. Use only when status reports `re_anchor` (no local baseline exists for this lane yet \u2014 fresh clone, deleted `.remix/` state, or first init didn't seed). Re-anchor does not replace `remix_collab_finalize_turn`; ordinary local content changes (including merges, pulls, and rebases) are recorded by `finalize-turn`, not by re-anchor.",
+    description: "Preview whether this checkout needs a fresh local Remix baseline. Use only when status reports `re_anchor` (no local baseline exists for this lane yet \u2014 fresh clone, deleted `.remix/` state, or first init didn't seed). Re-anchor does not replace automatic hook recording; ordinary local content changes (including merges, pulls, and rebases) are captured at the completed-turn boundary, not by re-anchor.",
     access: "read",
     inputSchema: previewInputSchema,
     outputSchema: reAnchorSuccessSchema,
@@ -2129,7 +2044,7 @@ function registerCollabTools(server, context) {
   });
   registerTool(server, context, {
     name: "remix_collab_re_anchor_apply",
-    description: "Establish a local Remix baseline for the current checkout against the existing app head, without rewriting the local checkout afterward. Required only when status reports `re_anchor` (missing local baseline). It does not replace `remix_collab_finalize_turn` \u2014 local commits, pulls, merges, and rebases must still be recorded with `finalize-turn`.",
+    description: "Establish a local Remix baseline for the current checkout against the existing app head, without rewriting the local checkout afterward. Required only when status reports `re_anchor` (missing local baseline). It does not replace automatic hook recording \u2014 local commits, pulls, merges, and rebases are still captured at the completed-turn boundary.",
     access: "local_write",
     inputSchema: reAnchorInputSchema,
     outputSchema: reAnchorSuccessSchema,