@stackwright-pro/mcp 0.2.0-alpha.97 → 0.2.0-alpha.99

package/dist/server.js

@@ -2024,6 +2024,7 @@ function registerOrchestrationTools(server2) {
 // src/tools/pipeline.ts
 var import_zod13 = require("zod");
 var import_fs6 = require("fs");
+var import_proper_lockfile = require("proper-lockfile");
 var import_path6 = require("path");
 var import_crypto3 = require("crypto");
 
@@ -2905,6 +2906,7 @@ function loadPipelineGraph() {
 }
 
 // src/tools/pipeline.ts
+var import_telemetry = require("@stackwright-pro/telemetry");
 var PHASE_ORDER = [
   "designer",
   "theme",
@@ -3015,6 +3017,27 @@ function writeState(cwd, state) {
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   safeWriteSync(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
 }
+function updateStateAtomic(cwd, mutator) {
+  const dir = (0, import_path6.join)(cwd, ".stackwright");
+  (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  const path4 = statePath(cwd);
+  if (!(0, import_fs6.existsSync)(path4)) {
+    safeWriteSync(path4, JSON.stringify(createDefaultState(), null, 2) + "\n");
+  }
+  const release = (0, import_proper_lockfile.lockSync)(path4, {
+    realpath: false,
+    stale: 1e4
+    // Treat locks older than 10s as stale (guards against crash mid-lock)
+  });
+  try {
+    const state = readState(cwd);
+    mutator(state);
+    writeState(cwd, state);
+    return state;
+  } finally {
+    release();
+  }
+}
 function extractJsonFromResponse(text) {
   let cleaned = text;
   cleaned = cleaned.replace(/```(?:json)?\s*/gi, "");
@@ -3090,35 +3113,57 @@ function handleSetPipelineState(input) {
     }
   }
   try {
-    const state = readState(cwd);
-    if (input.status) {
-      state.status = input.status;
-    }
-    if (input.phase) {
-      const phase = input.phase;
-      if (!state.phases[phase]) {
-        state.phases[phase] = defaultPhaseStatus();
+    const state = updateStateAtomic(cwd, (state2) => {
+      if (input.status) {
+        state2.status = input.status;
+      }
+      if (input.phase) {
+        const phase = input.phase;
+        if (!state2.phases[phase]) {
+          state2.phases[phase] = defaultPhaseStatus();
+        }
+        const phaseState = state2.phases[phase];
+        if (input.field && input.value !== void 0) {
+          phaseState[input.field] = input.value;
+        }
+        if (input.incrementRetry) {
+          phaseState.retryCount += 1;
+        }
+        state2.currentPhase = phase;
       }
-      const phaseState = state.phases[phase];
-      if (input.field && input.value !== void 0) {
-        phaseState[input.field] = input.value;
+      if (input.updates && input.updates.length > 0) {
+        for (const update of input.updates) {
+          if (!state2.phases[update.phase]) {
+            state2.phases[update.phase] = defaultPhaseStatus();
+          }
+          const batchPhaseState = state2.phases[update.phase];
+          batchPhaseState[update.field] = update.value;
+          state2.currentPhase = update.phase;
+        }
       }
-      if (input.incrementRetry) {
-        phaseState.retryCount += 1;
+    });
+    try {
+      const completedPhases = Object.entries(state.phases).filter(([, ps]) => ps.artifactWritten).map(([p]) => p);
+      (0, import_telemetry.emit)(
+        {
+          type: "pipeline_state_change",
+          state: state.status,
+          phases: { ready: [], completed: completedPhases, blocked: [] }
+        },
+        { cwd }
+      );
+      if (input.field === "artifactWritten" && input.value === true && input.phase) {
+        (0, import_telemetry.emit)({ type: "phase_complete", phase: input.phase }, { cwd });
       }
-      state.currentPhase = phase;
-    }
-    if (input.updates && input.updates.length > 0) {
-      for (const update of input.updates) {
-        if (!state.phases[update.phase]) {
-          state.phases[update.phase] = defaultPhaseStatus();
+      if (input.updates) {
+        for (const update of input.updates) {
+          if (update.field === "artifactWritten" && update.value === true) {
+            (0, import_telemetry.emit)({ type: "phase_complete", phase: update.phase }, { cwd });
+          }
         }
-        const batchPhaseState = state.phases[update.phase];
-        batchPhaseState[update.field] = update.value;
-        state.currentPhase = update.phase;
       }
+    } catch {
     }
-    writeState(cwd, state);
     return { text: JSON.stringify(state), isError: false };
   } catch (err) {
     return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
@@ -3311,11 +3356,11 @@ function handleWritePhaseQuestions(input) {
       requiredPackages
     };
     safeWriteSync(filePath, JSON.stringify(payload, null, 2) + "\n");
-    const state = readState(cwd);
-    if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
-    const ps = state.phases[phase];
-    ps.questionsCollected = true;
-    writeState(cwd, state);
+    updateStateAtomic(cwd, (state) => {
+      if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
+      const ps = state.phases[phase];
+      ps.questionsCollected = true;
+    });
     return {
       text: JSON.stringify({
         success: true,
@@ -3824,7 +3869,7 @@ var PHASE_ARTIFACT_SCHEMA = {
     2
   )
 };
-function handleValidateArtifact(input) {
+function _validateArtifactInner(input) {
   const cwd = input._cwd ?? process.cwd();
   const { phase, responseText, artifact: directArtifact } = input;
   if (!isValidPhase2(phase)) {
@@ -4028,11 +4073,11 @@ function handleValidateArtifact(input) {
       signed = true;
     } catch {
     }
-    const state = readState(cwd);
-    if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
-    const ps = state.phases[phase];
-    ps.artifactWritten = true;
-    writeState(cwd, state);
+    updateStateAtomic(cwd, (state) => {
+      if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
+      const ps = state.phases[phase];
+      ps.artifactWritten = true;
+    });
     const topKeys = Object.keys(artifact).slice(0, 5).join(", ");
     const result = {
       valid: true,
@@ -4046,6 +4091,32 @@ function handleValidateArtifact(input) {
     return { text: JSON.stringify({ error: true, phase, message }), isError: true };
   }
 }
+function handleValidateArtifact(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { phase } = input;
+  (0, import_telemetry.emit)(
+    { type: "tool_call", toolName: "stackwright_pro_validate_artifact", args: { phase }, phase },
+    { cwd }
+  );
+  const result = _validateArtifactInner(input);
+  try {
+    const parsed = JSON.parse(result.text);
+    if (parsed.valid === true && parsed.artifactPath) {
+      (0, import_telemetry.emit)({ type: "file_write", path: parsed.artifactPath, phase }, { cwd });
+    }
+    (0, import_telemetry.emit)(
+      {
+        type: "tool_complete",
+        toolName: "stackwright_pro_validate_artifact",
+        success: parsed.valid === true,
+        phase
+      },
+      { cwd }
+    );
+  } catch {
+  }
+  return result;
+}
 function registerPipelineTools(server2) {
   const DESC = "Writes state to .stackwright/ \u2014 the filesystem is the state machine.";
   const res = (r) => ({
@@ -4182,12 +4253,70 @@ function registerPipelineTools(server2) {
       return res(handleValidateArtifact({ phase, responseText: responseText ?? "" }));
     }
   );
+  server2.tool(
+    "stackwright_pro_emit_event",
+    `Emit a telemetry event to .stackwright/pipeline-events.ndjson. Foreman calls this at phase boundaries and agent-invoke boundaries. Best-effort: failures are silent and never block. ${DESC}`,
+    {
+      type: import_zod13.z.enum(["phase_start", "phase_complete", "agent_invoke_start", "agent_invoke_complete"]).describe("Event type to emit"),
+      phase: import_zod13.z.string().optional().describe("Current phase name"),
+      targetOtter: import_zod13.z.string().optional().describe("For agent_invoke_* events: which otter is being invoked"),
+      success: import_zod13.z.boolean().optional().describe("For agent_invoke_complete: did the invocation succeed?"),
+      otter: import_zod13.z.string().optional().describe('Which otter is emitting (defaults to "foreman")'),
+      durationSec: import_zod13.z.number().optional().describe("Duration in seconds (for *_complete events)")
+    },
+    async ({ type, phase, targetOtter, success, otter, durationSec }) => {
+      let emitted = false;
+      try {
+        if (type === "phase_start") {
+          if (!phase) {
+            return res({
+              text: JSON.stringify({ emitted: false, reason: "phase required for phase_start" }),
+              isError: false
+            });
+          }
+          emitted = (0, import_telemetry.emit)({ type: "phase_start", phase, otter: otter ?? "foreman" });
+        } else if (type === "phase_complete") {
+          if (!phase) {
+            return res({
+              text: JSON.stringify({ emitted: false, reason: "phase required for phase_complete" }),
+              isError: false
+            });
+          }
+          emitted = (0, import_telemetry.emit)({
+            type: "phase_complete",
+            phase,
+            otter: otter ?? "foreman",
+            ...durationSec != null ? { durationSec } : {}
+          });
+        } else if (type === "agent_invoke_start") {
+          emitted = (0, import_telemetry.emit)({
+            type: "agent_invoke_start",
+            targetOtter: targetOtter ?? "",
+            phase,
+            otter: otter ?? "foreman"
+          });
+        } else if (type === "agent_invoke_complete") {
+          emitted = (0, import_telemetry.emit)({
+            type: "agent_invoke_complete",
+            targetOtter: targetOtter ?? "",
+            success: success ?? true,
+            phase,
+            otter: otter ?? "foreman",
+            ...durationSec != null ? { durationSec } : {}
+          });
+        }
+      } catch {
+      }
+      return res({ text: JSON.stringify({ emitted }), isError: false });
+    }
+  );
 }
 
 // src/tools/safe-write.ts
 var import_zod14 = require("zod");
 var import_fs7 = require("fs");
 var import_path7 = require("path");
+var import_telemetry2 = require("@stackwright-pro/telemetry");
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
     { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Design language artifact" }
@@ -4515,7 +4644,7 @@ function validateContent(filePath, content) {
   if (filePath === ".env" || filePath.startsWith(".env")) return validateEnvContent(content);
   return null;
 }
-function handleSafeWrite(input) {
+function _safeWriteInner(input) {
   const cwd = input._cwd ?? process.cwd();
   const { callerOtter, filePath, content, createDirectories = true } = input;
   const check = checkPathAllowed(callerOtter, filePath);
@@ -4623,6 +4752,31 @@ function handleSafeWrite(input) {
     return { text: JSON.stringify(result), isError: true };
   }
 }
+function handleSafeWrite(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { filePath, callerOtter } = input;
+  (0, import_telemetry2.emit)(
+    { type: "tool_call", toolName: "stackwright_pro_safe_write", args: { callerOtter, filePath } },
+    { cwd }
+  );
+  const result = _safeWriteInner(input);
+  try {
+    const parsed = JSON.parse(result.text);
+    if (parsed.success === true && parsed.path) {
+      (0, import_telemetry2.emit)({ type: "file_write", path: parsed.path, bytes: parsed.bytesWritten }, { cwd });
+    }
+    (0, import_telemetry2.emit)(
+      {
+        type: "tool_complete",
+        toolName: "stackwright_pro_safe_write",
+        success: parsed.success === true
+      },
+      { cwd }
+    );
+  } catch {
+  }
+  return result;
+}
 function registerSafeWriteTools(server2) {
   const DESC = "Controlled file-write chokepoint. Every write from specialist otters goes through this tool with per-otter path allowlists. The LLM cannot write to arbitrary filesystem paths.";
   server2.tool(
@@ -5564,63 +5718,63 @@ var import_path9 = require("path");
 var _checksums = /* @__PURE__ */ new Map([
   [
     "stackwright-pro-api-otter.json",
-    "822b35d7a330ed8ac0b42a63b0f70a41885aa9b5ea23cc5b8b998b549da4c05c"
+    "b3ad28c4404af9fb3c2cfce258c707dadd37bc59ac236e1f46d6163cd8d5dc9b"
   ],
   [
     "stackwright-pro-auth-otter.json",
-    "d6cd5732667018d99456be77d5955e454da7a0999a0330b5f03a483aa1b9b33f"
+    "1a21d9f23e250f23291124307e5a2a32af5a716566319a3290372dae3d02e637"
   ],
   [
     "stackwright-pro-dashboard-otter.json",
-    "19268b1ab423bfbb628ebfbc9f6767d5c0bfedd03963c6d445a2724a8bb78f9c"
+    "d9277616db5680ce3d598908fa3a1b0d0f626e33948785a4c64703b85e463b31"
   ],
   [
     "stackwright-pro-data-otter.json",
-    "bb66eaab31c6872536dca4d3ff145724a46356946dd0665cc4f0346714d3bacb"
+    "536cba95f32667e81ae4b6335378a095f91095598defff0de00af231ebdbc488"
   ],
   [
     "stackwright-pro-designer-otter.json",
-    "b54121c6a2ab5b1ad68c1262c58b2e04e6315feacd6bb8de8e78eb36f2fa6be6"
+    "69a6c09fbb54f971c48eae7fd52faa63cf79be2923e435aca9ff802e8d541d0f"
   ],
   [
     "stackwright-pro-domain-expert-otter.json",
-    "1f21b8ff3450bdae29a4d31b31462ba22583995a448af3c11ab0a5071f46bd72"
+    "14d77cade020f44d1b5a2b406e2599501f3466ee90ca4248500a441d419bc59c"
   ],
   [
     "stackwright-pro-foreman-otter.json",
-    "abb1cc5e40a8c5ff98057273f43a9e90e2791a15951090cd4d98407c0c3618e3"
+    "9cbe27b8193ebec2ea916aee82d8bdc6c811cc64735923f36b93545a8f1f9551"
   ],
   [
     "stackwright-pro-form-wizard-otter.json",
-    "975ad68e8fb6fe5a10373be278946fa4d9d7ec2238a0b2bd9e4a412e5b1fdd6d"
+    "7f6f94192f26face57dc8b2e22e0a49d23ceeeb356ca4ebde05492f1b25e3c47"
   ],
   [
     "stackwright-pro-geo-otter.json",
-    "eef152e5b58947c8eb1ffec2c37acffc39f84b61be4c6cb827310f052221935b"
+    "15f2327b69f75a9c772c2acad5a5d6d3daefb7b55a079aca3205ecd4f33ae349"
   ],
   [
     "stackwright-pro-page-otter.json",
-    "ddfa497a4d4980080fa2918aec4d6dfd78d5c28ec6426b4b52f4f26fccaddabb"
+    "c467c5d03b69d87fb1efa9482674a25e2f63782189db74b65309928d47456176"
   ],
   [
     "stackwright-pro-polish-otter.json",
-    "5e6532c1fe0737ed83b1f46dd55642e1076adb6ef23d4de636523eb3d88d3087"
+    "1cfea28e121e30181b0a7c8bda0700ffc892a6f919a0ec64996a4cf3f7735b51"
   ],
   [
     "stackwright-pro-qa-otter.json",
-    "ecb1e76170723fce43f515044e304d9da32253dadecbf29bf08c90bb8f375f77"
+    "822075893bb4f8496f3dca7b0e68eda460a6fbde87480c13c194582eb7744318"
   ],
   [
     "stackwright-pro-scaffold-otter.json",
-    "96ac7754b54c15732206cd4d8043b558d0c465757a0bc70fae6b498d6f02f22a"
+    "341d74ff2be24893ed174e869dc40c090f82e25e11d412d63519944512c37f15"
   ],
   [
     "stackwright-pro-theme-otter.json",
-    "fb62e56642f7f94c50ce173f3e1ce978b3f20ab1567e87403b901d6dd991a7db"
+    "b0eccc1945e30b80a0f9a3209c5428e8e32cd09063bd9b2ef7ecb891343774f2"
   ],
   [
     "stackwright-services-otter.json",
-    "0a5dac670482871c718099767b30bf23d8ec57e942bd40a00ce295926d82c6bd"
+    "8997bdd9a6fd3e6e02563578a1649480bc21acf919534ae41f73e70ade7cf500"
   ]
 ]);
 Object.freeze(_checksums);
@@ -7059,14 +7213,17 @@ var package_default = {
     "@stackwright-pro/cli-data-explorer": "workspace:*",
     "@stackwright-pro/openapi": "workspace:*",
     "@stackwright-pro/pulse": "workspace:*",
+    "@stackwright-pro/telemetry": "workspace:*",
     "@stackwright-pro/types": "workspace:*",
     "@stackwright/mcp": "0.6.0-alpha.1",
     "@types/js-yaml": "^4.0.9",
     "js-yaml": "^4.2.0",
+    "proper-lockfile": "^4.1.2",
     zod: "^4.4.3"
   },
   devDependencies: {
     "@types/node": "catalog:",
+    "@types/proper-lockfile": "^4.1.4",
     tsup: "catalog:",
     typescript: "catalog:",
     vitest: "catalog:"
@@ -7080,7 +7237,7 @@ var package_default = {
     "test:coverage": "vitest run --coverage"
   },
   name: "@stackwright-pro/mcp",
-  version: "0.2.0-alpha.97",
+  version: "0.2.0-alpha.99",
   description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
   license: "SEE LICENSE IN LICENSE",
   main: "./dist/server.js",