@remixhq/claude-plugin 0.1.10 → 0.1.12

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "remix",
   "description": "Remix collaboration workflows for Claude Code",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "author": {
     "name": "Remix"
   },

package/dist/hook-post-collab.cjs

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,6 +26,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hook-post-collab.ts
+var hook_post_collab_exports = {};
+__export(hook_post_collab_exports, {
+  runHookPostCollab: () => runHookPostCollab
+});
+module.exports = __toCommonJS(hook_post_collab_exports);
+
+// src/hook-diagnostics.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/hook-state.ts
 var import_promises = __toESM(require("fs/promises"), 1);
@@ -29,7 +47,8 @@ var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
 function stateRoot() {
-  return import_node_path.default.join(import_node_os.default.tmpdir(), "remix-claude-plugin-hooks");
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_STATE_ROOT?.trim();
+  return configured || import_node_path.default.join(import_node_os.default.tmpdir(), "remix-claude-plugin-hooks");
 }
 function statePath(sessionId) {
   return import_node_path.default.join(stateRoot(), `${sessionId}.json`);
@@ -94,6 +113,7 @@ async function tryRemoveStaleStateLock(sessionId) {
 async function acquireStateLock(sessionId) {
   const lockPath = stateLockPath(sessionId);
   const deadline = Date.now() + STATE_LOCK_WAIT_MS;
+  await import_promises.default.mkdir(stateRoot(), { recursive: true });
   while (true) {
     try {
       await import_promises.default.mkdir(lockPath);
@@ -328,19 +348,139 @@ async function markPendingTurnConsultedMemory(sessionId) {
   });
 }
 
+// package.json
+var package_default = {
+  name: "@remixhq/claude-plugin",
+  version: "0.1.12",
+  description: "Claude Code plugin for Remix collaboration workflows",
+  homepage: "https://github.com/RemixDotOne/remix-claude-plugin",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/RemixDotOne/remix-claude-plugin.git"
+  },
+  type: "module",
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist",
+    ".claude-plugin/plugin.json",
+    ".mcp.json",
+    "skills",
+    "hooks",
+    "agents"
+  ],
+  scripts: {
+    build: "tsup",
+    postbuild: `node -e "const fs=require('node:fs'); for (const p of ['dist/mcp-server.cjs','dist/hook-pre-git.cjs','dist/hook-user-prompt.cjs','dist/hook-post-collab.cjs','dist/hook-stop-collab.cjs']) fs.chmodSync(p, 0o755);"`,
+    dev: "tsx src/mcp-server.ts",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    prepack: "npm run build"
+  },
+  dependencies: {
+    "@remixhq/core": "^0.1.8",
+    "@remixhq/mcp": "^0.1.8"
+  },
+  devDependencies: {
+    "@types/node": "^25.4.0",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/metadata.ts
+var pluginMetadata = {
+  name: package_default.name,
+  version: package_default.version,
+  description: package_default.description,
+  pluginId: "remix",
+  agentName: "remix-collab"
+};
+
+// src/hook-diagnostics.ts
+var MAX_LOG_BYTES = 512 * 1024;
+function resolveClaudeRoot() {
+  const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return configured || import_node_path2.default.join(import_node_os2.default.homedir(), ".claude");
+}
+function resolvePluginDataDirName() {
+  return `${pluginMetadata.pluginId}-${pluginMetadata.pluginId}`;
+}
+function getHookDiagnosticsDirPath() {
+  const configured = process.env.REMIX_CLAUDE_PLUGIN_HOOK_DIAGNOSTICS_DIR?.trim();
+  return configured || import_node_path2.default.join(resolveClaudeRoot(), "plugins", "data", resolvePluginDataDirName());
+}
+function getHookDiagnosticsLogPath() {
+  return import_node_path2.default.join(getHookDiagnosticsDirPath(), "hooks.ndjson");
+}
+function toFieldValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "boolean") return value;
+  return void 0;
+}
+function normalizeFields(fields) {
+  if (!fields) return {};
+  const normalizedEntries = Object.entries(fields).map(([key, value]) => {
+    const normalized = toFieldValue(value);
+    return normalized === void 0 ? null : [key, normalized];
+  }).filter((entry) => entry !== null);
+  return Object.fromEntries(normalizedEntries);
+}
+async function rotateLogIfNeeded(logPath) {
+  const stat = await import_promises2.default.stat(logPath).catch(() => null);
+  if (!stat || stat.size < MAX_LOG_BYTES) {
+    return;
+  }
+  const rotatedPath = `${logPath}.1`;
+  await import_promises2.default.rm(rotatedPath, { force: true }).catch(() => void 0);
+  await import_promises2.default.rename(logPath, rotatedPath).catch(() => void 0);
+}
+async function appendHookDiagnosticsEvent(params) {
+  try {
+    const logPath = getHookDiagnosticsLogPath();
+    await import_promises2.default.mkdir(import_node_path2.default.dirname(logPath), { recursive: true });
+    await rotateLogIfNeeded(logPath);
+    const event = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      hook: params.hook,
+      pluginVersion: pluginMetadata.version,
+      pid: process.pid,
+      sessionId: params.sessionId?.trim() || null,
+      turnId: params.turnId?.trim() || null,
+      stage: params.stage.trim(),
+      result: params.result,
+      reason: params.reason?.trim() || null,
+      toolName: params.toolName?.trim() || null,
+      repoRoot: params.repoRoot?.trim() || null,
+      message: params.message?.trim() || null,
+      fields: normalizeFields(params.fields)
+    };
+    await import_promises2.default.appendFile(logPath, `${JSON.stringify(event)}
+`, "utf8");
+  } catch {
+  }
+}
+
 // src/hook-utils.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 
 // node_modules/@remixhq/core/dist/chunk-FAZUMWBS.js
-var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_path = __toESM(require("path"), 1);
 function getCollabBindingPath(repoRoot) {
   return import_path.default.join(repoRoot, ".remix", "config.json");
 }
 async function readCollabBinding(repoRoot) {
   try {
-    const raw = await import_promises2.default.readFile(getCollabBindingPath(repoRoot), "utf8");
+    const raw = await import_promises3.default.readFile(getCollabBindingPath(repoRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.schemaVersion !== 1) return null;
     if (!parsed.projectId || !parsed.currentAppId || !parsed.upstreamAppId) return null;
@@ -462,7 +602,7 @@ function collectPathTargetsFromObject(input, keys) {
   return keys.flatMap((key) => collectStringPathValue(input[key]));
 }
 function resolveCandidatePath(targetPath, baseDir) {
-  return import_node_path2.default.isAbsolute(targetPath) ? import_node_path2.default.normalize(targetPath) : import_node_path2.default.resolve(baseDir, targetPath);
+  return import_node_path3.default.isAbsolute(targetPath) ? import_node_path3.default.normalize(targetPath) : import_node_path3.default.resolve(baseDir, targetPath);
 }
 function extractToolPathTargets(payload, toolName) {
   const name = (toolName ?? extractToolName(payload) ?? "").trim().toLowerCase();
@@ -474,16 +614,16 @@ function extractToolPathTargets(payload, toolName) {
 }
 async function findBoundRepo(startPath) {
   if (!startPath) return null;
-  let current = import_node_path2.default.resolve(startPath);
-  let stats = await import_promises3.default.stat(current).catch(() => null);
+  let current = import_node_path3.default.resolve(startPath);
+  let stats = await import_promises4.default.stat(current).catch(() => null);
   if (stats?.isFile()) {
-    current = import_node_path2.default.dirname(current);
+    current = import_node_path3.default.dirname(current);
   }
   while (true) {
-    const bindingPath = import_node_path2.default.join(current, ".remix", "config.json");
-    const bindingStats = await import_promises3.default.stat(bindingPath).catch(() => null);
+    const bindingPath = import_node_path3.default.join(current, ".remix", "config.json");
+    const bindingStats = await import_promises4.default.stat(bindingPath).catch(() => null);
     if (bindingStats?.isFile()) return current;
-    const parent = import_node_path2.default.dirname(current);
+    const parent = import_node_path3.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -580,20 +720,69 @@ function isLikelyMutatingShellCommand(command) {
   }
   return false;
 }
-async function main() {
-  const payload = await readJsonStdin();
+async function runHookPostCollab(payload) {
   const sessionId = typeof payload.session_id === "string" && payload.session_id.trim() ? payload.session_id.trim() : null;
   const toolName = normalizeHookToolName(extractToolName(payload));
+  await appendHookDiagnosticsEvent({
+    hook: "PostToolUse",
+    sessionId,
+    stage: "payload_received",
+    result: "start",
+    toolName,
+    fields: {
+      hasSessionId: Boolean(sessionId),
+      hasToolName: Boolean(toolName)
+    }
+  });
   if (!sessionId || !toolName) {
+    await appendHookDiagnosticsEvent({
+      hook: "PostToolUse",
+      sessionId,
+      stage: "payload_validation",
+      result: "skip",
+      reason: !sessionId ? "missing_session_id" : "missing_tool_name",
+      toolName
+    });
     return;
   }
   const toolSucceeded = didToolSucceed(payload);
   const remoteChangeRecordedButSyncFailed = isRemoteChangeRecordingToolName(toolName) && isRemoteChangeRecordedButLocalSyncFailed(payload);
+  await appendHookDiagnosticsEvent({
+    hook: "PostToolUse",
+    sessionId,
+    stage: "tool_classified",
+    result: "info",
+    toolName,
+    fields: {
+      toolSucceeded,
+      remoteChangeRecordedButSyncFailed,
+      isMemoryTool: isMemoryToolName(toolName),
+      isRepoMutationTool: isRepoMutationToolName(toolName),
+      isShellTool: isShellToolName(toolName),
+      isStructuredLocalWriteTool: isStructuredLocalWriteToolName(toolName),
+      isStructuredLocalReadTool: isStructuredLocalReadToolName(toolName)
+    }
+  });
   if (!toolSucceeded && !remoteChangeRecordedButSyncFailed) {
+    await appendHookDiagnosticsEvent({
+      hook: "PostToolUse",
+      sessionId,
+      stage: "tool_result_gate",
+      result: "skip",
+      reason: "tool_failed_or_skipped",
+      toolName
+    });
     return;
   }
   if (toolSucceeded && isMemoryToolName(toolName)) {
     await markPendingTurnConsultedMemory(sessionId);
+    await appendHookDiagnosticsEvent({
+      hook: "PostToolUse",
+      sessionId,
+      stage: "memory_marked_consulted",
+      result: "success",
+      toolName
+    });
   }
   const manualRecordingScope = getManualRecordingScope(toolName);
   if (isRepoMutationToolName(toolName) || manualRecordingScope) {
@@ -617,6 +806,28 @@ async function main() {
           remoteChangeRecorded: toolSucceeded ? isRemoteChangeRecordingToolName(toolName) : remoteChangeRecordedButSyncFailed
         });
       }
+      await appendHookDiagnosticsEvent({
+        hook: "PostToolUse",
+        sessionId,
+        stage: "repo_marked_from_tool_cwd",
+        result: "success",
+        toolName,
+        repoRoot: targetRepo.repoRoot,
+        fields: {
+          hasObservedWrite: isRepoMutationToolName(toolName),
+          manualRecordingScope,
+          remoteChangeRecordedButSyncFailed
+        }
+      });
+    } else {
+      await appendHookDiagnosticsEvent({
+        hook: "PostToolUse",
+        sessionId,
+        stage: "repo_marked_from_tool_cwd",
+        result: "skip",
+        reason: "repo_not_bound_from_tool_cwd",
+        toolName
+      });
     }
   }
   if (toolSucceeded && isShellToolName(toolName)) {
@@ -635,10 +846,44 @@ async function main() {
       if (hasObservedWrite) {
         await markTouchedRepoObservedWrite(sessionId, targetRepo.repoRoot, { toolName });
       }
+      await appendHookDiagnosticsEvent({
+        hook: "PostToolUse",
+        sessionId,
+        stage: "shell_repo_marked",
+        result: "success",
+        toolName,
+        repoRoot: targetRepo.repoRoot,
+        fields: {
+          hasObservedWrite,
+          bashCommandLength: bashCommand?.length ?? 0
+        }
+      });
+    } else {
+      await appendHookDiagnosticsEvent({
+        hook: "PostToolUse",
+        sessionId,
+        stage: "shell_repo_marked",
+        result: "skip",
+        reason: "repo_not_bound_from_shell_cwd",
+        toolName
+      });
     }
   }
   if (toolSucceeded && (isStructuredLocalWriteToolName(toolName) || isStructuredLocalReadToolName(toolName))) {
-    const touchedRepos = await resolveTouchedBoundReposFromPaths(extractToolPathTargets(payload, toolName));
+    const touchedPaths = extractToolPathTargets(payload, toolName);
+    const touchedRepos = await resolveTouchedBoundReposFromPaths(touchedPaths);
+    await appendHookDiagnosticsEvent({
+      hook: "PostToolUse",
+      sessionId,
+      stage: "path_targets_resolved",
+      result: touchedRepos.length > 0 ? "info" : "skip",
+      reason: touchedRepos.length > 0 ? null : "no_bound_repos_from_paths",
+      toolName,
+      fields: {
+        touchedPathCount: touchedPaths.length,
+        boundRepoCount: touchedRepos.length
+      }
+    });
     for (const repo of touchedRepos) {
       await upsertTouchedRepo(sessionId, {
         repoRoot: repo.repoRoot,
@@ -651,13 +896,46 @@ async function main() {
       if (isStructuredLocalWriteToolName(toolName)) {
         await markTouchedRepoObservedWrite(sessionId, repo.repoRoot, { toolName });
       }
+      await appendHookDiagnosticsEvent({
+        hook: "PostToolUse",
+        sessionId,
+        stage: "path_repo_marked",
+        result: "success",
+        toolName,
+        repoRoot: repo.repoRoot,
+        fields: {
+          hasObservedWrite: isStructuredLocalWriteToolName(toolName)
+        }
+      });
     }
   }
+  await appendHookDiagnosticsEvent({
+    hook: "PostToolUse",
+    sessionId,
+    stage: "completed",
+    result: "success",
+    toolName
+  });
+}
+async function main() {
+  const payload = await readJsonStdin();
+  await runHookPostCollab(payload);
 }
 main().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
+  void appendHookDiagnosticsEvent({
+    hook: "PostToolUse",
+    stage: "unhandled_error",
+    result: "error",
+    reason: "exception",
+    message
+  });
   process.stderr.write(`${message}
 `);
   process.exitCode = 0;
 });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runHookPostCollab
+});
 //# sourceMappingURL=hook-post-collab.cjs.map