@yugabytedb/meko-mcp 2.2.0 → 2.3.0

package/lib/migrate/id.mjs

@@ -3,6 +3,8 @@
  */
 
 import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 /**
@@ -44,7 +46,7 @@ export const COMMON_BUCKET_AGENT_ID = "meko_agent";
 
 const AGENT_ID_MAX_LEN = 64;
 const KNOWN_LOOSE_CLIENTS = new Set(["claude-desktop", "claude_desktop"]);
-const KNOWN_CODING_CLIENTS = new Set(["claude_code", "cursor", "codex", "kiro"]);
+const KNOWN_CODING_CLIENTS = new Set(["claude_code", "cursor", "codex", "kiro", "opencode"]);
 
 /**
  * Sanitize a project segment: lowercase, collapse non-`[a-z0-9-]` to `-`,
@@ -61,21 +63,125 @@ function sanitizeProjectSegment(segment) {
   return collapsed.slice(0, AGENT_ID_MAX_LEN);
 }
 
+/**
+ * The user's home directory, read fresh so tests (and shells that re-point
+ * `$HOME`) see the current value rather than a module-load snapshot.
+ *
+ * @returns {string|null}
+ */
+function homeBoundary() {
+  const fromEnv = (process.env.HOME || "").trim();
+  if (fromEnv) return path.resolve(fromEnv);
+  try {
+    const h = os.homedir();
+    return h ? path.resolve(h) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Walk parents of `cwd` looking for a `.git` entry (directory for a normal
+ * checkout, file for a submodule or linked worktree). Returns the absolute
+ * repo-root path, or `null` if none is found.
+ *
+ * The walk stops at `$HOME`: a directory under home that is not itself in a
+ * repo must NOT inherit home's repo-ness. Users who keep dotfiles under git
+ * would otherwise see every scratch directory collapse into
+ * `claude_code:<username>` — the same cross-project merge MEKO-590 exists to
+ * prevent, one level up. `$HOME` itself is still a valid repo root, so a
+ * session run directly in a git-tracked home resolves normally.
+ *
+ * Sync + best-effort: any I/O error at a level just skips that level. The
+ * caller treats `null` as "outside a repo" and falls back to the bare client
+ * name, per the MEKO-590 contract.
+ *
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function resolveRepoRoot(cwd) {
+  if (!cwd || typeof cwd !== "string") return null;
+  let dir;
+  try {
+    dir = path.resolve(cwd);
+  } catch {
+    return null;
+  }
+  const start = dir;
+  const home = homeBoundary();
+  let prev = null;
+  while (dir && dir !== prev) {
+    // A directory below a git-tracked home must not inherit home's `.git`.
+    if (home && dir === home && dir !== start) return null;
+    try {
+      fs.statSync(path.join(dir, ".git"));
+      return dir;
+    } catch {
+      // no .git here; keep walking
+    }
+    // Check home itself for `.git`, then stop. This lets a git-tracked home
+    // resolve as a repo root without allowing a non-git home to inherit a
+    // `.git` from /Users, /home, or /.
+    if (home && dir === home) return null;
+    prev = dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Repo root for a cwd that is HISTORICAL rather than live — a path recorded
+ * in an old transcript, or reverse-derived from a `~/.claude/projects/<slug>`
+ * directory name. Such a path may no longer exist (repo deleted, moved, or
+ * renamed) while its transcripts survive, so a filesystem walk is not a
+ * usable oracle.
+ *
+ * Walks first, so a repo still on disk gets the correct root. When the walk
+ * finds nothing, treats the recorded path's own basename as the project
+ * segment instead of reporting "outside a repo". That keeps each historical
+ * project in its own bucket: collapsing them all into a bare `claude_code`
+ * would re-create, inside the migrator, exactly the cross-repo merge
+ * MEKO-590 fixes in the hook.
+ *
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function repoRootForHistoricalCwd(cwd) {
+  if (!cwd || typeof cwd !== "string") return null;
+  const live = resolveRepoRoot(cwd);
+  if (live) return live;
+  try {
+    return path.resolve(cwd);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Derive an `agent_id` for a Meko write.
  *
- * Contract:
+ * Contract (MEKO-590):
  *   - `envOverride` (typically `MEKO_AGENT_ID`) wins if non-empty.
  *   - Loose clients (Claude Desktop) → bare `claude_desktop`; no schema.
- *   - Coding clients (Claude Code, Cursor, Codex, Kiro) → `<client>:<repo-basename>`.
- *     Outside a repo (basename is empty/`.`/`/`) → bare client name to
- *     keep coding-agent traffic out of the common bucket.
+ *   - Coding clients (Claude Code, Cursor, Codex, Kiro, OpenCode) →
+ *     `<client>:<repo-basename>`, resolved by walking parents of `cwd`
+ *     for a `.git` entry. The basename is lowercased and non-`[a-z0-9-]`
+ *     runs collapse to `-`. Outside a repo (no `.git` in any ancestor,
+ *     or basename sanitizes to empty) → bare client name, so sibling
+ *     directories named `docs` / `webapp` / `src` across unrelated repos
+ *     cannot silently collapse into one agent_id.
  *   - Anything else → `meko_agent` (the common cross-project bucket).
  *
+ * The `repoRoot` opt lets callers bypass the filesystem walk when they
+ * already know the repo root (or, for Cursor's flat project-name model,
+ * want to treat a supplied name as the basename directly). Passing
+ * `repoRoot: null` explicitly is an assertion of "outside a repo".
+ *
  * @param {object} opts
  * @param {string} [opts.client]       e.g. "claude_code", "cursor", "codex", "kiro", "claude-desktop"
  * @param {string} [opts.cwd]          Absolute working directory, for coding clients
  * @param {string} [opts.envOverride]  Raw value of `MEKO_AGENT_ID`, if set
+ * @param {string|null} [opts.repoRoot] Pre-resolved repo root; bypasses the FS walk when set
  * @returns {string}
  */
 export function deriveAgentId(opts = {}) {
@@ -86,13 +192,45 @@ export function deriveAgentId(opts = {}) {
   if (KNOWN_LOOSE_CLIENTS.has(client)) return "claude_desktop";
   if (!KNOWN_CODING_CLIENTS.has(client)) return COMMON_BUCKET_AGENT_ID;
 
-  const rawBase = opts.cwd ? path.basename(opts.cwd) : "";
-  if (!rawBase || rawBase === "." || rawBase === "/") return client;
-  const project = sanitizeProjectSegment(rawBase);
+  const repoRoot = Object.prototype.hasOwnProperty.call(opts, "repoRoot")
+    ? opts.repoRoot
+    : resolveRepoRoot(opts.cwd);
+  if (!repoRoot) return client;
+  const project = sanitizeProjectSegment(path.basename(repoRoot));
   if (!project) return client;
   return `${client}:${project}`;
 }
 
+/**
+ * Derive the coding-agent id used before MEKO-590: from the cwd's leaf
+ * basename without a repo-root walk. Persisted migrator state and datapack
+ * pin filenames may still use this value, so callers use it as a compatibility
+ * alias while new sessions use `deriveAgentId`.
+ *
+ * @param {object} opts
+ * @param {string} [opts.client]
+ * @param {string} [opts.cwd]
+ * @param {string} [opts.envOverride]
+ * @returns {string}
+ */
+export function deriveLegacyAgentId(opts = {}) {
+  const override = (opts.envOverride ?? "").trim();
+  if (override) return override;
+
+  const client = (opts.client ?? "").trim();
+  if (KNOWN_LOOSE_CLIENTS.has(client)) return "claude_desktop";
+  if (!KNOWN_CODING_CLIENTS.has(client)) return COMMON_BUCKET_AGENT_ID;
+
+  let rawBase = "";
+  try {
+    rawBase = opts.cwd ? path.basename(opts.cwd) : "";
+  } catch {
+    return client;
+  }
+  const project = sanitizeProjectSegment(rawBase);
+  return project ? `${client}:${project}` : client;
+}
+
 /**
  * Back-compat alias. New code should call `deriveAgentId(...)`.
  */
@@ -101,14 +239,23 @@ export const AGENT_ID = COMMON_BUCKET_AGENT_ID;
 /**
  * @param {string} [cwd] Absolute project cwd. Required for project-scope
  *   writes; omit for user-scope writes (returns the common bucket).
+ *
+ * Pass `{ historical: true }` when `cwd` came from a recorded transcript or
+ * a reverse-slugged project directory rather than the live process. The repo
+ * root is then resolved via `repoRootForHistoricalCwd`, which falls back to
+ * the recorded basename when the path no longer exists on disk, so projects
+ * whose repos were deleted or moved keep distinct buckets.
+ * @param {object} [opts]
+ * @param {boolean} [opts.historical] Treat `cwd` as a recorded path.
  * @returns {string}
  */
-export function agentIdForClaude(cwd) {
+export function agentIdForClaude(cwd, opts = {}) {
   if (!cwd) return COMMON_BUCKET_AGENT_ID;
   return deriveAgentId({
     client: "claude_code",
     cwd,
     envOverride: process.env.MEKO_AGENT_ID,
+    ...(opts.historical ? { repoRoot: repoRootForHistoricalCwd(cwd) } : {}),
   });
 }
 
@@ -122,13 +269,19 @@ export const CLAUDE_CODE_USER_AGENT_ID = COMMON_BUCKET_AGENT_ID;
 /**
  * @param {string} [cwd] Absolute project cwd (or basename — Cursor's projects
  *   live under a flat `~/.cursor/projects/<name>/`). Omit for user-scope.
+ *
+ * Cursor's persisted transcripts store a flat project name rather than a
+ * full absolute cwd, so we treat the supplied value as the repo basename
+ * directly (via `repoRoot`) instead of walking the filesystem for a `.git`
+ * that isn't there.
+ *
  * @returns {string}
  */
 export function agentIdForCursor(cwd) {
   if (!cwd) return COMMON_BUCKET_AGENT_ID;
   return deriveAgentId({
     client: "cursor",
-    cwd,
+    repoRoot: cwd,
     envOverride: process.env.MEKO_AGENT_ID,
   });
 }
@@ -137,24 +290,53 @@ export function agentIdForCursor(cwd) {
  * @param {string} [cwd] Absolute project cwd of the Codex session (from the
  *   rollout's `session_meta.payload.cwd`). Omit for user-scope writes
  *   (returns the common bucket).
+ *
+ * Pass `{ historical: true }` when `cwd` came from a recorded transcript or
+ * a reverse-slugged project directory rather than the live process. The repo
+ * root is then resolved via `repoRootForHistoricalCwd`, which falls back to
+ * the recorded basename when the path no longer exists on disk, so projects
+ * whose repos were deleted or moved keep distinct buckets.
+ * @param {object} [opts]
+ * @param {boolean} [opts.historical] Treat `cwd` as a recorded path.
  * @returns {string}
  */
-export function agentIdForCodex(cwd) {
+export function agentIdForCodex(cwd, opts = {}) {
   if (!cwd) return COMMON_BUCKET_AGENT_ID;
   return deriveAgentId({
     client: "codex",
     cwd,
     envOverride: process.env.MEKO_AGENT_ID,
+    ...(opts.historical ? { repoRoot: repoRootForHistoricalCwd(cwd) } : {}),
   });
 }
 
-/** Derive the project-scoped owner used by Kiro hook capture. */
-export function agentIdForKiro(cwd) {
+/**
+ * Derive the project-scoped owner used by Kiro hook capture.
+ *
+ * Pass `{ historical: true }` when `cwd` came from a recorded transcript or
+ * a reverse-slugged project directory rather than the live process. The repo
+ * root is then resolved via `repoRootForHistoricalCwd`, which falls back to
+ * the recorded basename when the path no longer exists on disk, so projects
+ * whose repos were deleted or moved keep distinct buckets.
+ */
+export function agentIdForKiro(cwd, opts = {}) {
   if (!cwd) return COMMON_BUCKET_AGENT_ID;
   return deriveAgentId({
     client: "kiro",
     cwd,
     envOverride: process.env.MEKO_AGENT_ID,
+    ...(opts.historical ? { repoRoot: repoRootForHistoricalCwd(cwd) } : {}),
+  });
+}
+
+/** Derive the project-scoped owner used by OpenCode capture and migration. */
+export function agentIdForOpenCode(cwd, opts = {}) {
+  if (!cwd) return COMMON_BUCKET_AGENT_ID;
+  return deriveAgentId({
+    client: "opencode",
+    cwd,
+    envOverride: process.env.MEKO_AGENT_ID,
+    ...(opts.historical ? { repoRoot: repoRootForHistoricalCwd(cwd) } : {}),
   });
 }
 

package/lib/migrate/mcp-client.mjs

@@ -93,7 +93,31 @@ export class McpClient {
         lastErr = err;
         const code = err.statusCode;
         if (code === 401 || code === 403) {
-          // Auth is fatal; surface immediately.
+          // Auth errors are never worth retrying: the same credential will
+          // be rejected again. Whether they're fatal depends on the caller.
+          //
+          // A fire-and-forget call is one whose loss the run can absorb
+          // (conversation_add_message, memory_add). A token that expires
+          // partway through a multi-hour migration used to kill the whole
+          // run from inside one such call; now the call is dropped, the skip
+          // is recorded, and the run finishes with the gap visible.
+          //
+          // The initial auth probe is `connect()`, which does not come
+          // through here, so a bad key still aborts before any work starts.
+          if (opts.fireAndForget) {
+            this.log.warn?.("mcp_skipped_auth", {
+              tool: name,
+              statusCode: code,
+              error: err.message,
+            });
+            return {
+              ok: false,
+              skipped: true,
+              authSkipped: true,
+              statusCode: code,
+              error: { message: err.message },
+            };
+          }
           throw err;
         }
         if (attempt < maxRetries) {

package/lib/migrate/opencode-normalizer.mjs

@@ -0,0 +1,132 @@
+/** OpenCode session → canonical exchanges. Keep in sync with the CJS handler mirror. */
+
+const SYNTHETIC_PART_TYPES = new Set(["compaction", "subtask", "continuation"]);
+const EXCLUDED_PART_TYPES = new Set([
+  "tool", "tool-invocation", "tool-result", "tool_result", "reasoning",
+  "file", "attachment", "step", "snapshot", "patch",
+]);
+const INTERRUPTED_MARKER =
+  "[Meko capture: assistant response was interrupted before completion.]";
+export function normalizeOpenCodeSession(exportShape, opts = {}) {
+  const root = exportShape && typeof exportShape === "object" ? exportShape : {};
+  const info = root.info && typeof root.info === "object" ? root.info : {};
+  const rawMessages = Array.isArray(root.messages) ? root.messages : [];
+  const sessionId = firstString(info.id, info.sessionID, info.sessionId, root.sessionId) || "unknown";
+  const cwd = firstString(info.cwd, info.directory, info.projectPath, root.cwd) || "";
+  const parentSessionId = firstString(info.parentID, info.parentId, info.parentSessionId) || null;
+  const title = firstString(info.title, info.name) || sessionId;
+  const startedAt = firstTimestamp(info.time?.created, info.created, info.startedAt, info.time);
+  const visibleMessages = rawMessages.map(normalizeMessage).filter(Boolean).sort(compareMessageOrder);
+  const exchanges = [];
+  let pendingUser = null;
+  let firstUserText = "";
+  for (const msg of visibleMessages) {
+    if (msg.role === "user") {
+      if (pendingUser) exchanges.push(makeExchange(pendingUser, null, { forceInterrupted: true }));
+      pendingUser = msg;
+      if (!firstUserText && msg.text) firstUserText = msg.text.slice(0, 240);
+    } else if (msg.role === "assistant" && pendingUser) {
+      exchanges.push(makeExchange(pendingUser, msg, {}));
+      pendingUser = null;
+    }
+  }
+  let partial = Boolean(pendingUser);
+  if (pendingUser && (opts.terminalError || opts.interrupted)) {
+    exchanges.push(makeExchange(pendingUser, null, { ...opts, interrupted: true }));
+    pendingUser = null;
+    partial = false;
+  } else if (!pendingUser && (opts.terminalError || opts.interrupted) && exchanges.length) {
+    markInterrupted(exchanges[exchanges.length - 1]);
+  }
+  return {
+    sessionId, cwd, parentSessionId, title,
+    startedAt: startedAt || visibleMessages[0]?.timestamp || null,
+    firstUserText,
+    exchanges: exchanges.filter((ex) => ex.input || ex.output),
+    partial,
+  };
+}
+function normalizeMessage(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const info = raw.info && typeof raw.info === "object" ? raw.info : raw;
+  const role = firstString(info.role, raw.role)?.toLowerCase();
+  if (role !== "user" && role !== "assistant") return null;
+  const synthetic = Boolean(
+    info.synthetic || info.compaction || info.subtask || info.continuation ||
+    SYNTHETIC_PART_TYPES.has(String(info.type || "").toLowerCase()),
+  );
+  if (synthetic) return null;
+  const parts = Array.isArray(raw.parts) ? raw.parts : [];
+  const text = joinVisibleText(parts);
+  if (!text && role === "assistant") return null;
+  return {
+    role,
+    id: firstString(info.id, raw.id, raw.uuid) || "",
+    timestamp: firstTimestamp(info.time?.created, info.createdAt, info.timestamp, raw.timestamp) || "",
+    text,
+    order: Number.isFinite(Number(info.order)) ? Number(info.order) : null,
+  };
+}
+function joinVisibleText(parts) {
+  const chunks = [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    if (part.synthetic || part.ignored) continue;
+    const type = String(part.type || "text").toLowerCase();
+    if (EXCLUDED_PART_TYPES.has(type) || SYNTHETIC_PART_TYPES.has(type)) continue;
+    if (type !== "text") continue;
+    const text = typeof part.text === "string" ? part.text : "";
+    if (!text.trim()) continue;
+    chunks.push(text);
+  }
+  return chunks.join("\n");
+}
+function compareMessageOrder(a, b) {
+  const ao = a.order; const bo = b.order;
+  if (ao != null && bo != null && ao !== bo) return ao - bo;
+  if (a.timestamp && b.timestamp && a.timestamp !== b.timestamp) {
+    return a.timestamp < b.timestamp ? -1 : 1;
+  }
+  return String(a.id).localeCompare(String(b.id));
+}
+function makeExchange(userMsg, assistantMsg, opts) {
+  const interrupted = Boolean(opts.interrupted || (!assistantMsg && opts.forceInterrupted));
+  return {
+    userId: userMsg.id || `opencode-user-${hashish(userMsg.text)}`,
+    assistantId: assistantMsg?.id || null,
+    input: userMsg.text,
+    output: interrupted ? INTERRUPTED_MARKER : (assistantMsg?.text || ""),
+    timestamp: assistantMsg?.timestamp || userMsg.timestamp || "",
+    interrupted,
+  };
+}
+function markInterrupted(exchange) {
+  exchange.interrupted = true;
+  exchange.output = exchange.output
+    ? `${exchange.output}\n\n${INTERRUPTED_MARKER}`
+    : INTERRUPTED_MARKER;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function firstTimestamp(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) return date.toISOString();
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+  }
+  return "";
+}
+function hashish(text) {
+  let h = 0;
+  const s = String(text || "");
+  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+  return Math.abs(h).toString(36);
+}
+export { INTERRUPTED_MARKER };