@yugabytedb/meko-mcp 2.2.0 → 2.5.0

package/assets/hooks-handlers/lib/journal-bridge.js

@@ -0,0 +1,218 @@
+/** Fsynced OpenCode journal primitives; Kiro keeps a separate implementation. */
+"use strict";
+const fs = require("fs");
+const LOCK_RETRIES = 100;
+const LOCK_RETRY_MS = 10;
+function sleepSync(ms) {
+  const cell = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(cell, 0, 0, ms);
+}
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureEventDir(eventDir) {
+  fs.mkdirSync(eventDir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(eventDir, 0o700); } catch { /* best effort */ }
+}
+function acquireEventLock(lockPath, eventDir) {
+  ensureEventDir(eventDir);
+  for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
+    try {
+      const fd = fs.openSync(lockPath, "wx", 0o600);
+      try {
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, created_at: Date.now() }));
+      } finally {
+        fs.closeSync(fd);
+      }
+      return true;
+    } catch (err) {
+      if (!err || err.code !== "EEXIST") throw err;
+      let existing = null;
+      try { existing = JSON.parse(fs.readFileSync(lockPath, "utf8")); } catch {
+        try {
+          const st = fs.statSync(lockPath);
+          if (Date.now() - st.mtimeMs < 2000) {
+            sleepSync(LOCK_RETRY_MS);
+            continue;
+          }
+        } catch { /* gone */ }
+      }
+      if (!existing || !pidAlive(Number(existing.pid))) {
+        try { fs.unlinkSync(lockPath); } catch { /* another process won */ }
+        continue;
+      }
+      sleepSync(LOCK_RETRY_MS);
+    }
+  }
+  throw new Error(`timed out acquiring event lock ${lockPath}`);
+}
+function releaseEventLock(lockPath) {
+  try {
+    const current = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    if (Number(current.pid) === process.pid) fs.unlinkSync(lockPath);
+  } catch { /* already gone */ }
+}
+function atomicWriteJson(filePath, value, eventDir) {
+  ensureEventDir(eventDir);
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  const fd = fs.openSync(tmp, "w", 0o600);
+  try {
+    fs.writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, filePath);
+  try { fs.chmodSync(filePath, 0o600); } catch { /* best effort */ }
+}
+function appendJournal(journalPath, record, eventDir) {
+  ensureEventDir(eventDir);
+  let separator = "";
+  try {
+    const contents = fs.readFileSync(journalPath);
+    if (contents.length > 0 && contents[contents.length - 1] !== 0x0a) {
+      separator = "\n";
+    }
+  } catch (err) {
+    if (!err || err.code !== "ENOENT") throw err;
+  }
+  const data = Buffer.from(`${separator}${JSON.stringify(record)}\n`, "utf8");
+  const fd = fs.openSync(journalPath, "a", 0o600);
+  try {
+    let offset = 0;
+    while (offset < data.length) {
+      const written = fs.writeSync(fd, data, offset, data.length - offset, null);
+      if (!Number.isInteger(written) || written <= 0) {
+        throw new Error(`could not append complete journal record to ${journalPath}`);
+      }
+      offset += written;
+    }
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try { fs.chmodSync(journalPath, 0o600); } catch { /* best effort */ }
+}
+function journalEmpty(journalPath) {
+  try { return fs.statSync(journalPath).size === 0; } catch { return true; }
+}
+function emptyEventState(sessionId) {
+  return {
+    schema_version: 1,
+    session_id: sessionId,
+    turn_index: 0,
+    pending: null,
+    seen_source_ids: [],
+    updated_at: new Date().toISOString(),
+  };
+}
+function rebuildEventState(journalPath, sessionId) {
+  const rebuilt = emptyEventState(sessionId);
+  let contents;
+  try {
+    contents = fs.readFileSync(journalPath, "utf8");
+  } catch {
+    return rebuilt;
+  }
+  for (const line of contents.split("\n")) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!record || record.session_id !== sessionId) continue;
+    if (record.type === "user") {
+      const content = record.message && record.message.content;
+      const text = Array.isArray(content) && content[0] && typeof content[0].text === "string"
+        ? content[0].text
+        : "";
+      const uuid = String(record.uuid || "");
+      rebuilt.turn_index += 1;
+      const mekoObservedMs =
+        record.meko && Number.isFinite(record.meko.observed_at_ms)
+          ? record.meko.observed_at_ms
+          : null;
+      const firstObservedAtMs = mekoObservedMs;
+      rebuilt.pending = {
+        user_uuid: uuid,
+        source_message_id: record.source_message_id || null,
+        turn_index: rebuilt.turn_index,
+        prompt_preview: text.slice(0, 80),
+        first_observed_at_ms: firstObservedAtMs,
+      };
+      if (record.source_message_id) rebuilt.seen_source_ids.push(record.source_message_id);
+      // Alias `${userId}:interrupted` so a later original id is already seen.
+      const legacySuffix = ":interrupted";
+      if (uuid.endsWith(legacySuffix)) {
+        const base = uuid.slice(0, -legacySuffix.length);
+        if (base) rebuilt.seen_source_ids.push(base);
+      }
+    } else if (record.type === "assistant" && rebuilt.pending) {
+      if (record.source_message_id) rebuilt.seen_source_ids.push(record.source_message_id);
+      rebuilt.pending = null;
+    }
+  }
+  return rebuilt;
+}
+function readEventState(statePath, journalPath, sessionId, eventDir) {
+  let persisted = null;
+  try {
+    const value = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    if (value && value.schema_version === 1 && value.session_id === sessionId) {
+      persisted = value;
+    }
+  } catch { /* fresh or corrupt rebuildable sidecar */ }
+  const rebuilt = rebuildEventState(journalPath, sessionId);
+  // MEKO-635: prefer the persisted pending's first_observed_at_ms over the
+  // rebuild value from record.meko.observed_at_ms. Fall back to rebuild when
+  // the sidecar is missing or names a different pending user.
+  let pending = rebuilt.pending;
+  const persistedPending = persisted && persisted.pending;
+  if (
+    pending &&
+    persistedPending &&
+    persistedPending.user_uuid === pending.user_uuid
+  ) {
+    const persistedMs = persistedPending.first_observed_at_ms;
+    pending = {
+      ...pending,
+      first_observed_at_ms: Number.isFinite(persistedMs)
+        ? persistedMs
+        : pending.first_observed_at_ms,
+    };
+  }
+  return {
+    ...(persisted || emptyEventState(sessionId)),
+    turn_index: rebuilt.turn_index,
+    pending,
+    seen_source_ids: rebuilt.seen_source_ids,
+    tentative_observation:
+      pending &&
+      persisted &&
+      persisted.pending &&
+      persisted.pending.user_uuid === pending.user_uuid
+        ? persisted.tentative_observation || null
+        : null,
+  };
+}
+module.exports = {
+  LOCK_RETRIES,
+  LOCK_RETRY_MS,
+  ensureEventDir,
+  acquireEventLock,
+  releaseEventLock,
+  atomicWriteJson,
+  appendJournal,
+  journalEmpty,
+  emptyEventState,
+  rebuildEventState,
+  readEventState,
+};

package/assets/hooks-handlers/lib/kiro-handler.js

@@ -535,20 +535,42 @@ function journalEvent(event) {
 }
 
 function ensureCaptureIntent(event, journalPath) {
-  const agentId = deriveAgentId({
+  const envOverride = (process.env.MEKO_AGENT_ID || "").trim();
+  const derivedAgentId = deriveAgentId({
     client: "kiro",
     cwd: event.cwd,
-    envOverride: process.env.MEKO_AGENT_ID,
+    envOverride,
   });
+  const existing = captureState.readState(event.sessionId);
+  const existingAgentId = existing.ok && existing.state
+    ? String(existing.state.agent_id || "").trim()
+    : "";
+  const existingSource = existing.ok && existing.state
+    ? String(existing.state.agent_id_source || "").trim()
+    : "";
+
+  // Existing Kiro sessions keep their persisted owner. Changing it in place
+  // would orphan an already-created conversation and reset the capture intent.
+  // A live explicit override still wins, and stale pre-MEKO-385 client ids are
+  // allowed to upgrade to Kiro.
+  const preserveExisting = !envOverride && existingAgentId && (
+    existingSource === "explicit"
+    || existingAgentId === "kiro"
+    || existingAgentId.startsWith("kiro:")
+  );
+  const agentId = preserveExisting ? existingAgentId : derivedAgentId;
+  const agentIdSource = preserveExisting
+    ? (existingSource || "derived")
+    : (envOverride ? "explicit" : "derived");
   const intent = captureState.writeSessionIntent(event.sessionId, {
     client: "kiro",
     agent_id: agentId,
-    agent_id_source: (process.env.MEKO_AGENT_ID || "").trim() ? "explicit" : "derived",
+    agent_id_source: agentIdSource,
     transcript_path: journalPath,
     datapack_id: process.env.MEKO_DATAPACK_ID || null,
     datapack_name: process.env.MEKO_DATAPACK_NAME || null,
   });
-  return { ...intent, agentId };
+  return { ...intent, agentId, derivedAgentId };
 }
 
 function launchCapture(mode, payload) {