@yugabytedb/meko-mcp 2.1.0 → 2.3.0

package/assets/opencode-plugin/meko.js

@@ -0,0 +1,213 @@
+// Managed by meko installer; reinstall rather than editing.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const PLUGIN_DIR = path.dirname(fileURLToPath(import.meta.url));
+const MEKO_ROOT = path.join(PLUGIN_DIR, "..", "meko");
+const ENV_PATH = path.join(MEKO_ROOT, "opencode-hook-env.json");
+const HANDLER_PATH = path.join(MEKO_ROOT, "hooks-handlers", "lib", "opencode-handler.js");
+const MANAGED_MARKER = "Managed by meko installer";
+function readEnv() {
+  try {
+    return JSON.parse(fs.readFileSync(ENV_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+// MEKO-635: staged snapshots live under the durable Capture v2 watermark root
+// (matches skills/hooks-handlers/lib/capture-state.js). This keeps them
+// outside installer-owned runtime and lets uninstall preserve them.
+function resolveStagingDir(env) {
+  const watermarkDir =
+    (typeof env.MEKO_WATERMARK_DIR === "string" && env.MEKO_WATERMARK_DIR) ||
+    path.join(os.homedir(), ".claude", "meko-capture");
+  return path.join(watermarkDir, "opencode-snapshots");
+}
+function safeSegment(value) {
+  return String(value || "unknown").replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 120);
+}
+function sanitizeSnapshot(session, messages) {
+  return {
+    info: {
+      id: session?.id,
+      title: session?.title,
+      directory: session?.directory,
+      parentID: session?.parentID,
+      time: session?.time,
+    },
+    messages: (Array.isArray(messages) ? messages : []).map((message) => ({
+      info: {
+        id: message?.info?.id,
+        role: message?.info?.role,
+        type: message?.info?.type,
+        order: message?.info?.order,
+        synthetic: message?.info?.synthetic,
+        compaction: message?.info?.compaction,
+        subtask: message?.info?.subtask,
+        continuation: message?.info?.continuation,
+        time: message?.info?.time,
+        createdAt: message?.info?.createdAt,
+        timestamp: message?.info?.timestamp,
+      },
+      parts: (Array.isArray(message?.parts) ? message.parts : [])
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => ({
+          type: "text",
+          text: part.text,
+          synthetic: Boolean(part.synthetic),
+          ignored: Boolean(part.ignored),
+        })),
+    })),
+  };
+}
+function stageSnapshot(sessionId, snapshot, terminalError, stagingDir) {
+  fs.mkdirSync(stagingDir, { recursive: true, mode: 0o700 });
+  // MEKO-635: two events in the same PID and millisecond can race. The 8-byte
+  // random suffix makes both the target and the temp path collision-proof so a
+  // session.error and a session.idle firing back-to-back cannot overwrite each
+  // other (nor let a late pending snapshot clobber one the reconciler is
+  // about to read).
+  const unique = randomBytes(8).toString("hex");
+  const target = path.join(
+    stagingDir,
+    `${safeSegment(sessionId)}.${process.pid}.${Date.now()}.${unique}.json`,
+  );
+  const tmp = `${target}.tmp`;
+  fs.writeFileSync(
+    tmp,
+    JSON.stringify({
+      schema_version: 1,
+      terminalError: Boolean(terminalError),
+      export: snapshot,
+    }),
+    { encoding: "utf8", mode: 0o600 },
+  );
+  fs.renameSync(tmp, target);
+  try { fs.chmodSync(target, 0o600); } catch { /* best effort */ }
+  return target;
+}
+function launchHandler(stagedPath, nodeExecutable, spawnProcess) {
+  if (!nodeExecutable) {
+    throw new Error("MEKO_NODE_EXECUTABLE is missing; reinstall Meko for OpenCode");
+  }
+  const child = spawnProcess(nodeExecutable, [HANDLER_PATH], {
+    detached: false,
+    stdio: ["pipe", "ignore", "ignore"],
+    env: {
+      ...process.env,
+      MEKO_OPENCODE_ENV_FILE: ENV_PATH,
+      MEKO_HOOK_CLIENT: "opencode",
+    },
+  });
+  child.once?.("error", (err) => {
+    console.error(`[meko-opencode] handler launch failed: ${err.message}`);
+  });
+  child.stdin?.on?.("error", () => {});
+  child.stdin?.end?.(JSON.stringify({ snapshotPath: stagedPath }));
+  return new Promise((resolve) => {
+    if (!child || typeof child.once !== "function") {
+      resolve();
+      return;
+    }
+    const done = () => resolve();
+    child.once("exit", done);
+    child.once("close", done);
+  });
+}
+async function captureSession(
+  client,
+  sessionID,
+  terminalError,
+  nodeExecutable,
+  spawnProcess,
+  stagingDir,
+) {
+  if (!sessionID) return;
+  let staged = "";
+  try {
+    const [sessionResponse, messagesResponse] = await Promise.all([
+      client.session.get({ path: { id: sessionID } }),
+      client.session.messages({ path: { id: sessionID } }),
+    ]);
+    const session = sessionResponse?.data;
+    const messages = messagesResponse?.data;
+    if (!session || !Array.isArray(messages)) {
+      throw new Error("OpenCode SDK returned an incomplete session snapshot");
+    }
+    staged = stageSnapshot(
+      session.id || sessionID,
+      sanitizeSnapshot(session, messages),
+      terminalError,
+      stagingDir,
+    );
+    await launchHandler(staged, nodeExecutable, spawnProcess);
+  } catch (err) {
+    console.error(`[meko-opencode] capture failed: ${err.message}`);
+  }
+}
+export default async function MekoPlugin({ client }, options = {}) {
+  const runtimeEnv = readEnv();
+  const nodeExecutable = runtimeEnv.MEKO_NODE_EXECUTABLE;
+  const stagingDir = resolveStagingDir(runtimeEnv);
+  const spawnProcess =
+    typeof options.__mekoSpawn === "function" ? options.__mekoSpawn : spawn;
+  const sessionTails = new Map();
+  function enqueue(sessionID, task) {
+    const key = sessionID || "_";
+    const next = (sessionTails.get(key) || Promise.resolve()).then(task, task);
+    sessionTails.set(key, next);
+    return next;
+  }
+  if (process.env.MEKO_OPENCODE_DISABLE_RECOVERY !== "1") {
+    try {
+      if (!nodeExecutable) {
+        throw new Error("MEKO_NODE_EXECUTABLE is missing; reinstall Meko for OpenCode");
+      }
+      spawnProcess(nodeExecutable, [HANDLER_PATH, "--recovery-scan"], {
+        detached: true,
+        windowsHide: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          MEKO_OPENCODE_ENV_FILE: ENV_PATH,
+          MEKO_HOOK_CLIENT: "opencode",
+        },
+      }).unref();
+    } catch (err) {
+      console.error(`[meko-opencode] recovery scan failed: ${err.message}`);
+    }
+  }
+
+  return {
+    async config(config) {
+      const env = readEnv();
+      const serverName = env.MEKO_MCP_SERVER_NAME || "meko";
+      if (!env.MEKO_MCP_URL) return;
+      const headers = {
+        "User-Agent": env.MEKO_MCP_USER_AGENT || "meko-mcp-installer/1.0",
+      };
+      if (env.MEKO_API_KEY) headers.Authorization = `Bearer ${env.MEKO_API_KEY}`;
+      config.mcp ??= {};
+      config.mcp[serverName] = {
+        type: "remote",
+        url: env.MEKO_MCP_URL,
+        enabled: true,
+        oauth: false,
+        headers,
+      };
+    },
+    async event({ event }) {
+      const sessionID = event.properties?.sessionID;
+      if (event?.type === "session.idle") {
+        await enqueue(sessionID, () =>
+          captureSession(client, sessionID, false, nodeExecutable, spawnProcess, stagingDir));
+      } else if (event?.type === "session.error") {
+        await enqueue(sessionID, () =>
+          captureSession(client, sessionID, true, nodeExecutable, spawnProcess, stagingDir));
+      }
+    },
+  };
+}

package/assets/scripts/meko-statusline.sh

@@ -46,12 +46,18 @@ fi
 
 # --- Derive agent_id from cwd ---
 #
-# Mirrors deriveAgentId() in skills/hooks-handlers/lib/capture.js:51-65:
-#   - basename of cwd, lowercased
+# Mirrors deriveAgentId() + resolveRepoRoot() in
+# skills/hooks-handlers/lib/capture.js:
+#   - walk parents of cwd for a '.git' entry (dir OR file, for worktrees and
+#     submodules); the walk stops at $HOME from below, so a git-tracked home
+#     does not claim every directory beneath it
+#   - basename of that repo root, lowercased
 #   - non-[a-z0-9-]+ → '-'
 #   - trim leading/trailing '-'
 #   - max 64 chars
 #   - prefix with 'claude_code:'
+#   - no repo root found → bare 'claude_code' (NOT 'claude_code:<leaf>'), so
+#     this segment reads the same pin file the hook writes
 #
 # Then mirrors datapackPinSlug() in capture.js:341-348:
 #   - non-[A-Za-z0-9._-]+ → '_'
@@ -74,19 +80,72 @@ if [[ -n "$STDIN_PAYLOAD" ]]; then
   fi
 fi
 
+if [[ -n "${HOME:-}" ]]; then
+  USER_HOME="$(cd -L -- "$HOME" 2>/dev/null && pwd -L)"
+else
+  USER_HOME="$(cd -L -- ~ 2>/dev/null && pwd -L)"
+fi
+
 # MEKO_AGENT_ID overrides the cwd-derived id, matching resolveSessionAgentId() in
 # capture.js (the env override wins verbatim when non-empty).
 if [[ -n "${MEKO_AGENT_ID:-}" ]]; then
   AGENT_ID="$MEKO_AGENT_ID"
+  LEGACY_AGENT_ID="$MEKO_AGENT_ID"
 else
-  BASENAME="$(basename "$CWD")"
-  PROJECT_SLUG="$(printf '%s' "$BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
-  PROJECT_SLUG="${PROJECT_SLUG:0:64}"
+  # Walk up from $CWD for a '.git' entry. $HOME bounds the walk from below.
+  REPO_ROOT=""
+  # Normalize relative paths and '..' before the textual $HOME comparison,
+  # matching path.resolve() for live directories. Unlike JavaScript's lexical
+  # resolution, cd/pwd requires the directory to exist; statusline cwd does.
+  START_DIR="$(cd -L -- "$CWD" 2>/dev/null && pwd -L)"
+  if [[ -z "$START_DIR" ]]; then
+    START_DIR="${CWD%/}"
+    [[ -z "$START_DIR" ]] && START_DIR="$CWD"
+  fi
+  WALK_DIR="$START_DIR"
+  HOME_BOUND="$USER_HOME"
+  while [[ -n "$WALK_DIR" ]]; do
+    # A directory below a git-tracked home must not inherit home's .git.
+    if [[ -n "$HOME_BOUND" && "$WALK_DIR" == "$HOME_BOUND" && "$WALK_DIR" != "$START_DIR" ]]; then
+      break
+    fi
+    if [[ -e "$WALK_DIR/.git" ]]; then
+      REPO_ROOT="$WALK_DIR"
+      break
+    fi
+    # Check home itself for .git, then stop. A non-git home must not inherit
+    # repository state from /Users, /home, or /.
+    if [[ -n "$HOME_BOUND" && "$WALK_DIR" == "$HOME_BOUND" ]]; then
+      break
+    fi
+    PARENT="$(dirname "$WALK_DIR")"
+    [[ "$PARENT" == "$WALK_DIR" ]] && break
+    WALK_DIR="$PARENT"
+  done
 
-  if [[ -z "$PROJECT_SLUG" || "$PROJECT_SLUG" == "-" ]]; then
+  if [[ -z "$REPO_ROOT" ]]; then
+    # Outside any repo: bare client name, matching deriveAgentId().
     AGENT_ID="claude_code"
   else
-    AGENT_ID="claude_code:$PROJECT_SLUG"
+    BASENAME="$(basename "$REPO_ROOT")"
+    PROJECT_SLUG="$(printf '%s' "$BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
+    PROJECT_SLUG="${PROJECT_SLUG:0:64}"
+
+    if [[ -z "$PROJECT_SLUG" || "$PROJECT_SLUG" == "-" ]]; then
+      AGENT_ID="claude_code"
+    else
+      AGENT_ID="claude_code:$PROJECT_SLUG"
+    fi
+  fi
+
+  # Read-only compatibility alias for pins written before MEKO-590.
+  LEGACY_BASENAME="$(basename "$CWD")"
+  LEGACY_SLUG="$(printf '%s' "$LEGACY_BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
+  LEGACY_SLUG="${LEGACY_SLUG:0:64}"
+  if [[ -n "$LEGACY_SLUG" && "$LEGACY_SLUG" != "-" ]]; then
+    LEGACY_AGENT_ID="claude_code:$LEGACY_SLUG"
+  else
+    LEGACY_AGENT_ID="claude_code"
   fi
 fi
 
@@ -96,22 +155,70 @@ PIN_SLUG="$(printf '%s' "$AGENT_ID" | sed -E 's/[^A-Za-z0-9._-]+/_/g; s/^_+|_+$/
 if [[ -z "$PIN_SLUG" ]]; then
   PIN_SLUG="meko_agent"
 fi
-PIN_FILE="${MEKO_WATERMARK_DIR:-$HOME/.claude/meko-capture}/pin-${PIN_SLUG}.json"
+PIN_DIR="${MEKO_WATERMARK_DIR:-$USER_HOME/.claude/meko-capture}"
+PIN_FILE="${PIN_DIR}/pin-${PIN_SLUG}.json"
+LEGACY_PIN_SLUG="$(printf '%s' "$LEGACY_AGENT_ID" | sed -E 's/[^A-Za-z0-9._-]+/_/g; s/^_+|_+$//g')"
+[[ -z "$LEGACY_PIN_SLUG" ]] && LEGACY_PIN_SLUG="meko_agent"
+LEGACY_PIN_FILE="${PIN_DIR}/pin-${LEGACY_PIN_SLUG}.json"
 
 # --- Read the pin file and append the suffix if a valid pin is present ---
 
+HAVE_SEGMENT=0
+if [[ -n "${INNER_OUT:-}" ]]; then
+  HAVE_SEGMENT=1
+fi
+
+PIN_NAME=""
 if [[ -f "$PIN_FILE" ]]; then
   # grep -oE isolates the exact "datapack_name":"…" pair before extracting, so a
   # greedy `.*` can't grab a different key that merely ends in datapack_name.
   PIN_NAME="$(grep -oE '"datapack_name"[[:space:]]*:[[:space:]]*"[^"]+"' "$PIN_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
-  if [[ -n "$PIN_NAME" ]]; then
-    SUFFIX="Meko: $PIN_NAME"
-    # Add a separator only if the inner command produced output.
-    if [[ -n "${INNER_OUT:-}" ]]; then
-      printf ' \xe2\x80\xa2 %s' "$SUFFIX"
-    else
-      printf '%s' "$SUFFIX"
-    fi
+fi
+if [[ -z "$PIN_NAME" && "$LEGACY_PIN_FILE" != "$PIN_FILE" && -f "$LEGACY_PIN_FILE" ]]; then
+  PIN_NAME="$(grep -oE '"datapack_name"[[:space:]]*:[[:space:]]*"[^"]+"' "$LEGACY_PIN_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+fi
+if [[ -n "$PIN_NAME" ]]; then
+  SUFFIX="Meko: $PIN_NAME"
+  # Add a separator only if the inner command produced output.
+  if [[ "$HAVE_SEGMENT" -eq 1 ]]; then
+    printf ' \xe2\x80\xa2 %s' "$SUFFIX"
+  else
+    printf '%s' "$SUFFIX"
+  fi
+  HAVE_SEGMENT=1
+fi
+
+# --- Capture health suffix (Capture V2) ---
+#
+# Composable: appends only for catching_up / degraded / blocked. Healthy adds
+# nothing. Reads rebuildable capture-health.json (no full watermark scan).
+# Format mirrors statuslineSuffixFromHealth() in capture-notices.js.
+
+WATERMARK_DIR="$PIN_DIR"
+HEALTH_FILE="${WATERMARK_DIR}/capture-health.json"
+CAPTURE_SUFFIX=""
+if [[ -f "$HEALTH_FILE" ]]; then
+  HEALTH_STATUS="$(grep -oE '"status"[[:space:]]*:[[:space:]]*"[^"]+"' "$HEALTH_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+  QUEUED="$(grep -oE '"queued_exchanges"[[:space:]]*:[[:space:]]*[0-9]+' "$HEALTH_FILE" | sed -E 's/.*:[[:space:]]*([0-9]+)$/\1/' | head -n 1)"
+  QUEUED="${QUEUED:-0}"
+  case "$HEALTH_STATUS" in
+    catching_up)
+      CAPTURE_SUFFIX="capture:catching_up(${QUEUED})"
+      ;;
+    degraded_retrying)
+      CAPTURE_SUFFIX="capture:degraded(${QUEUED})"
+      ;;
+    blocked_action_required)
+      CAPTURE_SUFFIX="capture:blocked(${QUEUED})"
+      ;;
+  esac
+fi
+
+if [[ -n "$CAPTURE_SUFFIX" ]]; then
+  if [[ "$HAVE_SEGMENT" -eq 1 ]]; then
+    printf ' \xe2\x80\xa2 %s' "$CAPTURE_SUFFIX"
+  else
+    printf '%s' "$CAPTURE_SUFFIX"
   fi
 fi