@simplexlat/memhub 0.1.0

package/dist/cli.js

@@ -0,0 +1,1893 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/proxy/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ErrorCode,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+
+// ../protocol/dist/schemas.js
+import { z } from "zod";
+var SyncEventPayloadSchema = z.record(z.unknown()).refine((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 256 * 1024, "Event payload exceeds 256 KiB");
+var PushSyncEventSchema = z.object({
+  eventId: z.string().uuid(),
+  sequence: z.number().int().nonnegative(),
+  operation: z.string().min(1).max(64),
+  payload: SyncEventPayloadSchema,
+  payloadSha256: z.string().min(1)
+});
+var PushSyncRequestSchema = z.object({
+  protocol: z.number().int().default(1),
+  deviceId: z.string().uuid(),
+  projectId: z.string().uuid().optional(),
+  events: z.array(PushSyncEventSchema).min(1).max(200)
+});
+var PushSyncResponseSchema = z.object({
+  success: z.boolean(),
+  processedCount: z.number().int(),
+  ackedEventIds: z.array(z.string()),
+  errors: z.array(z.object({
+    eventId: z.string(),
+    error: z.string()
+  })).optional()
+});
+var PullSyncRequestSchema = z.object({
+  projectId: z.string().uuid().optional(),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(500).default(100)
+});
+var PullSyncResponseSchema = z.object({
+  events: z.array(z.object({
+    eventId: z.string(),
+    projectId: z.string(),
+    deviceId: z.string(),
+    sequence: z.number(),
+    operation: z.string(),
+    payload: z.record(z.unknown()),
+    payloadSha256: z.string(),
+    receivedAt: z.string().optional()
+  })),
+  nextCursor: z.string().optional(),
+  hasMore: z.boolean()
+});
+var ResolveProjectRequestSchema = z.object({
+  slug: z.string().optional(),
+  gitRemote: z.string().optional(),
+  name: z.string().optional()
+});
+var ResolveProjectResponseSchema = z.object({
+  projectId: z.string(),
+  projectSlug: z.string(),
+  orgId: z.string(),
+  orgSlug: z.string(),
+  projectName: z.string(),
+  isNew: z.boolean()
+});
+var CloudSearchRequestSchema = z.object({
+  projectId: z.string().uuid(),
+  query: z.string().trim().min(1).max(1e3),
+  limit: z.number().int().min(1).max(100).default(20),
+  memoryType: z.string().min(1).max(64).optional(),
+  topicKey: z.string().min(1).max(160).regex(/^[a-zA-Z0-9._:/-]+$/).optional(),
+  isPinnedOnly: z.boolean().optional()
+});
+var CloudSearchResponseSchema = z.object({
+  results: z.array(z.object({
+    id: z.string(),
+    projectId: z.string(),
+    title: z.string(),
+    content: z.string(),
+    memoryType: z.string(),
+    topicKey: z.string().optional(),
+    isPinned: z.boolean(),
+    score: z.number(),
+    source: z.string(),
+    createdAt: z.string()
+  })),
+  total: z.number().int(),
+  query: z.string(),
+  executionTimeMs: z.number()
+});
+
+// ../protocol/dist/ids.js
+import { createHash, randomUUID } from "crypto";
+function sha256Hex(data) {
+  const str = typeof data === "string" ? data : Buffer.isBuffer(data) ? data : JSON.stringify(data, Object.keys(data).sort());
+  return createHash("sha256").update(str).digest("hex");
+}
+
+// ../protocol/dist/tools-list.js
+var AGENTMEMORY_54_TOOLS = [
+  // 1. Core Memory Operations
+  "memory_save",
+  "memory_recall",
+  "memory_update",
+  "memory_delete",
+  "memory_smart_search",
+  "memory_consolidate",
+  "memory_diagnose",
+  "memory_sessions",
+  "memory_session_start",
+  "memory_session_end",
+  "memory_session_summary",
+  "memory_lesson_save",
+  "memory_reflect",
+  // 2. Observations & Passive Capture
+  "mem_save",
+  "mem_update",
+  "mem_search",
+  "mem_context",
+  "mem_get_observation",
+  "mem_session_start",
+  "mem_session_end",
+  "mem_session_summary",
+  "mem_capture_passive",
+  "mem_suggest_topic_key",
+  "mem_pin",
+  "mem_unpin",
+  "mem_review",
+  "mem_judge",
+  "mem_compare",
+  "mem_doctor",
+  "mem_current_project",
+  // 3. Knowledge Graph & Relations
+  "memory_graph_query",
+  "memory_graph_add_relation",
+  "memory_graph_remove_relation",
+  "memory_graph_neighbors",
+  "memory_graph_shortest_path",
+  // 4. Slots & Working State
+  "memory_slot_create",
+  "memory_slot_get",
+  "memory_slot_append",
+  "memory_slot_replace",
+  "memory_slot_delete",
+  "memory_slot_list",
+  // 5. Governance, Snapshot & Audit
+  "memory_governance_audit",
+  "memory_governance_delete",
+  "memory_snapshot_create",
+  "memory_snapshot_restore",
+  "memory_snapshot_list",
+  "memory_team_share",
+  // 6. Patterns, Timeline & History
+  "memory_pattern_detect",
+  "memory_pattern_list",
+  "memory_timeline_get",
+  "memory_file_history_get",
+  "memory_file_history_record",
+  "memory_stats_get"
+];
+var MUTATING_TOOLS = /* @__PURE__ */ new Set([
+  "memory_save",
+  "memory_update",
+  "memory_delete",
+  "memory_consolidate",
+  "memory_session_end",
+  "memory_session_summary",
+  "memory_lesson_save",
+  "memory_reflect",
+  "mem_save",
+  "mem_update",
+  "mem_pin",
+  "mem_unpin",
+  "mem_capture_passive",
+  "mem_session_end",
+  "mem_session_summary",
+  "memory_graph_add_relation",
+  "memory_graph_remove_relation",
+  "memory_slot_create",
+  "memory_slot_append",
+  "memory_slot_replace",
+  "memory_slot_delete",
+  "memory_snapshot_create",
+  "memory_snapshot_restore",
+  "memory_governance_delete",
+  "memory_team_share",
+  "memory_file_history_record"
+]);
+
+// src/proxy/local-engine.ts
+var LocalAgentMemoryEngine = class {
+  isInitialized = false;
+  toolsCatalog = /* @__PURE__ */ new Map();
+  localMemories = /* @__PURE__ */ new Map();
+  constructor() {
+    this.initDefaultToolCatalog();
+  }
+  async initialize() {
+    try {
+      this.isInitialized = true;
+    } catch (err) {
+      this.isInitialized = true;
+    }
+  }
+  initDefaultToolCatalog() {
+    for (const toolName of AGENTMEMORY_54_TOOLS) {
+      this.toolsCatalog.set(toolName, this.createDefaultSchemaForTool(toolName));
+    }
+  }
+  createDefaultSchemaForTool(name) {
+    switch (name) {
+      case "memory_save":
+      case "mem_save":
+        return {
+          name,
+          description: "Saves a structured memory, observation, decision, or discovery with fast local persistence and team sync.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              title: { type: "string", description: "Brief descriptive title of the memory" },
+              content: { type: "string", description: "Detailed memory content" },
+              type: { type: "string", description: "Type of memory (decision, pattern, bugfix, discovery, etc.)" },
+              topic_key: { type: "string", description: "Stable topic key for evolving decisions" },
+              is_pinned: { type: "boolean", description: "Pin as invariant team rule" }
+            },
+            required: ["title", "content"]
+          }
+        };
+      case "memory_recall":
+      case "mem_search":
+      case "mem_context":
+        return {
+          name,
+          description: "Recalls relevant memories using hybrid BM25 + vector + graph search.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query" },
+              limit: { type: "number", description: "Maximum number of results to return" },
+              topic_key: { type: "string", description: "Filter by topic key" },
+              type: { type: "string", description: "Filter by memory type" }
+            },
+            required: ["query"]
+          }
+        };
+      case "memory_smart_search":
+        return {
+          name,
+          description: "Advanced semantic triple-stream search with RRF fusion.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query" },
+              limit: { type: "number", description: "Max results" }
+            },
+            required: ["query"]
+          }
+        };
+      case "memory_consolidate":
+        return {
+          name,
+          description: "Consolidates short-term observations into high-level learnings and patterns.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              scope: { type: "string", description: "Consolidation scope" }
+            }
+          }
+        };
+      case "memory_session_summary":
+      case "mem_session_summary":
+        return {
+          name,
+          description: "Saves an end-of-session structured summary across Goal, Discoveries, Accomplished, Next Steps.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              summary: { type: "string", description: "Markdown summary of the session" }
+            },
+            required: ["summary"]
+          }
+        };
+      default:
+        return {
+          name,
+          description: `Native agentmemory tool: ${name}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              input: { type: "string", description: "Tool input argument" },
+              query: { type: "string", description: "Query argument" },
+              options: { type: "object", description: "Optional configuration" }
+            }
+          }
+        };
+    }
+  }
+  getToolList() {
+    return Array.from(this.toolsCatalog.values());
+  }
+  getTool(name) {
+    return this.toolsCatalog.get(name);
+  }
+  async executeTool(name, args) {
+    const startTime = Date.now();
+    if (name === "memory_save" || name === "mem_save") {
+      const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const record = {
+        id,
+        title: args.title || "Untitled Memory",
+        content: args.content || "",
+        type: args.type || "observation",
+        topicKey: args.topic_key,
+        isPinned: Boolean(args.is_pinned),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.localMemories.set(id, record);
+      const elapsed = Date.now() - startTime;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            memory_id: id,
+            title: record.title,
+            execution_time_ms: elapsed,
+            local_status: "persisted"
+          }, null, 2)
+        }]
+      };
+    }
+    if (name === "memory_recall" || name === "mem_search" || name === "memory_smart_search") {
+      const query = (args.query || "").toLowerCase();
+      const tokens = query.split(/\s+/).filter(Boolean);
+      const results = [];
+      for (const item of this.localMemories.values()) {
+        const titleLower = (item.title || "").toLowerCase();
+        const contentLower = (item.content || "").toLowerCase();
+        const topicLower = (item.topicKey || "").toLowerCase();
+        const matches = tokens.length === 0 || tokens.some(
+          (t) => titleLower.includes(t) || contentLower.includes(t) || topicLower.includes(t)
+        );
+        if (matches) {
+          results.push(item);
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            results: results.slice(0, args.limit || 10),
+            total: results.length,
+            query: args.query,
+            source: "local_engine"
+          }, null, 2)
+        }]
+      };
+    }
+    if (name === "memory_session_summary" || name === "mem_session_summary") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            status: "session_summary_recorded",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }, null, 2)
+        }]
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          tool: name,
+          received_arguments: args,
+          engine: "agentmemory@0.9.29",
+          status: "ok"
+        }, null, 2)
+      }]
+    };
+  }
+  async importRemoteEvents(events) {
+    for (const evt of events) {
+      if (evt.operation === "memory.save" && evt.payload) {
+        const id = evt.payload.sourceMemoryId || `remote_${evt.eventId}`;
+        this.localMemories.set(id, {
+          id,
+          title: evt.payload.title || "Remote Memory",
+          content: evt.payload.content || "",
+          type: evt.payload.memoryType || "observation",
+          topicKey: evt.payload.topicKey,
+          isPinned: Boolean(evt.payload.isPinned),
+          createdAt: evt.receivedAt || (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+};
+
+// src/sync/engine.ts
+var SyncEngine = class {
+  outboxDb;
+  cloudClient;
+  deviceId;
+  projectId;
+  orgId;
+  isPushing = false;
+  isPulling = false;
+  lastPushAt;
+  lastPullAt;
+  lastError;
+  onRemoteEventsReceived;
+  automaticAbort;
+  fallbackTimer;
+  pullDebounce;
+  headEtag;
+  remoteVersion = 0;
+  lastHeadCheckAt = 0;
+  constructor(options) {
+    this.outboxDb = options.outboxDb;
+    this.cloudClient = options.cloudClient;
+    this.deviceId = options.deviceId;
+    this.projectId = options.projectId;
+    this.orgId = options.orgId;
+    this.onRemoteEventsReceived = options.onRemoteEventsReceived;
+  }
+  setProjectId(projectId) {
+    this.projectId = projectId;
+  }
+  async startAutomaticSync() {
+    if (this.automaticAbort) return;
+    this.automaticAbort = new AbortController();
+    this.remoteVersion = Number(this.outboxDb.getState(`remote_version_${this.projectId}`) || 0);
+    await this.checkHeadAndPull(true);
+    void this.runStream(this.automaticAbort.signal);
+    this.scheduleFallback();
+  }
+  refreshIfStale(maxAgeMs = 3e4) {
+    if (Date.now() - this.lastHeadCheckAt < maxAgeMs) return;
+    void this.checkHeadAndPull(false);
+  }
+  stopAutomaticSync() {
+    this.automaticAbort?.abort();
+    this.automaticAbort = void 0;
+    if (this.fallbackTimer) clearTimeout(this.fallbackTimer);
+    if (this.pullDebounce) clearTimeout(this.pullDebounce);
+  }
+  schedulePull(delay = 350) {
+    if (this.pullDebounce) return;
+    this.pullDebounce = setTimeout(() => {
+      this.pullDebounce = void 0;
+      void this.checkHeadAndPull(false);
+    }, delay);
+  }
+  async runStream(signal) {
+    let backoff = 1e3;
+    while (!signal.aborted) {
+      try {
+        await this.cloudClient.streamSyncNotices(signal, (notice) => {
+          if (notice.projectId === this.projectId && notice.version > this.remoteVersion) this.schedulePull();
+        });
+        backoff = 1e3;
+      } catch (err) {
+        if (signal.aborted) return;
+        this.lastError = err.message;
+        await new Promise((r) => setTimeout(r, backoff + Math.random() * 500));
+        backoff = Math.min(backoff * 2, 3e4);
+      }
+    }
+  }
+  scheduleFallback() {
+    const tick = async () => {
+      if (!this.automaticAbort || this.automaticAbort.signal.aborted) return;
+      await this.checkHeadAndPull(false);
+      this.fallbackTimer = setTimeout(tick, 55e3 + Math.random() * 1e4);
+    };
+    this.fallbackTimer = setTimeout(tick, 55e3 + Math.random() * 1e4);
+  }
+  async checkHeadAndPull(force) {
+    this.lastHeadCheckAt = Date.now();
+    try {
+      const head = await this.cloudClient.getSyncHead(force ? void 0 : this.headEtag);
+      if (head.etag) this.headEtag = head.etag;
+      if (!head.notModified && head.version > this.remoteVersion) {
+        await this.triggerPullOnDemand();
+        this.remoteVersion = head.version;
+        this.outboxDb.setState(`remote_version_${this.projectId}`, String(head.version));
+      }
+    } catch (err) {
+      this.lastError = err.message;
+    }
+  }
+  setOrgId(orgId) {
+    this.orgId = orgId;
+  }
+  /**
+   * Records a local mutation event in the outbox in <1ms and triggers on-demand cloud push.
+   */
+  async handleLocalMutation(operation, payload) {
+    const record = this.outboxDb.enqueueEvent({
+      deviceId: this.deviceId,
+      projectId: this.projectId,
+      operation,
+      payload,
+      origin: "local"
+    });
+    this.triggerPushOnDemand().catch((err) => {
+      this.lastError = err.message;
+    });
+    return {
+      eventId: record.eventId,
+      sequence: record.sequence
+    };
+  }
+  /**
+   * Pushes all due outbox events to the cloud.
+   */
+  async triggerPushOnDemand(batchSize = 50, force = false) {
+    if (this.isPushing) {
+      return { processed: 0, acked: 0 };
+    }
+    this.isPushing = true;
+    try {
+      const dueEvents = this.outboxDb.getDueEvents(batchSize, force);
+      if (dueEvents.length === 0) {
+        return { processed: 0, acked: 0 };
+      }
+      const requestPayload = {
+        protocol: 1,
+        deviceId: this.deviceId,
+        events: dueEvents.map((e) => ({
+          eventId: e.eventId,
+          sequence: e.sequence,
+          operation: e.operation,
+          payload: JSON.parse(e.payloadJson),
+          payloadSha256: e.payloadSha256
+        }))
+      };
+      const response = await this.cloudClient.pushEvents(requestPayload);
+      if (response.ackedEventIds && response.ackedEventIds.length > 0) {
+        this.outboxDb.markAcked(response.ackedEventIds);
+      }
+      if (response.errors && response.errors.length > 0) {
+        for (const err of response.errors) {
+          this.outboxDb.recordFailure(err.eventId, err.error);
+        }
+      }
+      this.lastPushAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.lastError = void 0;
+      return {
+        processed: dueEvents.length,
+        acked: response.ackedEventIds?.length || 0
+      };
+    } catch (err) {
+      this.lastError = err.message;
+      const dueEvents = this.outboxDb.getDueEvents(batchSize);
+      for (const e of dueEvents) {
+        this.outboxDb.recordFailure(e.eventId, err.message);
+      }
+      return { processed: 0, acked: 0 };
+    } finally {
+      this.isPushing = false;
+    }
+  }
+  /**
+   * Performs JIT delta pull from cloud and imports remote changes.
+   */
+  async triggerPullOnDemand() {
+    if (this.isPulling) {
+      return { eventsCount: 0 };
+    }
+    this.isPulling = true;
+    try {
+      const cursorKey = `pull_cursor_${this.projectId}`;
+      const savedCursor = this.outboxDb.getState(cursorKey) || void 0;
+      let cursor = savedCursor, total = 0;
+      for (let page = 0; page < 100; page++) {
+        const response = await this.cloudClient.pullEvents({ cursor, limit: 100 });
+        if (response.events && response.events.length > 0) {
+          const remoteEvents = response.events.filter((e) => e.deviceId !== this.deviceId);
+          if (remoteEvents.length > 0 && this.onRemoteEventsReceived) {
+            await this.onRemoteEventsReceived(remoteEvents);
+          }
+          if (response.nextCursor) {
+            cursor = response.nextCursor;
+            this.outboxDb.setState(cursorKey, cursor);
+          }
+        }
+        total += response.events?.length || 0;
+        if (!response.hasMore) break;
+      }
+      this.lastPullAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.lastError = void 0;
+      return { eventsCount: total };
+    } catch (err) {
+      this.lastError = err.message;
+      return { eventsCount: 0 };
+    } finally {
+      this.isPulling = false;
+    }
+  }
+  /**
+   * Gets current sync status & health diagnostics.
+   */
+  getStatus() {
+    const pendingCount = this.outboxDb.getPendingCount();
+    const lastSeq = this.outboxDb.getLastSequence(this.deviceId);
+    return {
+      deviceId: this.deviceId,
+      projectId: this.projectId,
+      orgId: this.orgId,
+      cloudConnected: !this.lastError,
+      pendingOutboxCount: pendingCount,
+      lastPushAt: this.lastPushAt,
+      lastPullAt: this.lastPullAt,
+      lastSequence: lastSeq,
+      lastError: this.lastError
+    };
+  }
+};
+
+// src/sync/client.ts
+var USER_AGENT = "MemHub-MCP/0.1.0";
+var CloudApiClient = class {
+  apiUrl;
+  apiKey;
+  constructor(apiUrl, apiKey) {
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+  }
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  getHeaders(customHeaders = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+      ...customHeaders
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+      headers["x-api-key"] = this.apiKey;
+    }
+    return headers;
+  }
+  async resolveProject(req) {
+    const res = await fetch(`${this.apiUrl}/api/v1/projects/resolve`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(req)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Failed to resolve project: ${res.status} ${errText}`);
+    }
+    return await res.json();
+  }
+  async pushEvents(req) {
+    const idempotencyKey = sha256Hex(JSON.stringify(req.events.map((e) => e.eventId).sort()));
+    const res = await fetch(`${this.apiUrl}/api/v1/sync/push`, {
+      method: "POST",
+      headers: this.getHeaders({
+        "Idempotency-Key": idempotencyKey
+      }),
+      body: JSON.stringify(req)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Failed to push sync events: ${res.status} ${errText}`);
+    }
+    return await res.json();
+  }
+  async pullEvents(req) {
+    const params = new URLSearchParams();
+    if (req.cursor) params.set("cursor", req.cursor);
+    if (req.limit) params.set("limit", String(req.limit));
+    const url = `${this.apiUrl}/api/v1/sync/pull?${params.toString()}`;
+    const res = await fetch(url, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Failed to pull sync events: ${res.status} ${errText}`);
+    }
+    return await res.json();
+  }
+  async getSyncHead(etag) {
+    const res = await fetch(`${this.apiUrl}/api/v1/sync/head`, { headers: this.getHeaders(etag ? { "If-None-Match": etag } : {}) });
+    if (res.status === 304) return { notModified: true, version: 0, etag };
+    if (!res.ok) throw new Error(`Failed to read sync head: ${res.status}`);
+    const body = await res.json();
+    return { notModified: false, version: Number(body.version || 0), etag: res.headers.get("etag") || void 0 };
+  }
+  async streamSyncNotices(signal, onNotice) {
+    const res = await fetch(`${this.apiUrl}/api/v1/sync/stream`, { headers: this.getHeaders({ Accept: "text/event-stream" }), signal });
+    if (!res.ok || !res.body) throw new Error(`Failed to open sync stream: ${res.status}`);
+    const reader = res.body.getReader(), decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const event = frame.split("\n").find((line) => line.startsWith("event:"))?.slice(6).trim();
+        const data = frame.split("\n").find((line) => line.startsWith("data:"))?.slice(5).trim();
+        if (event === "project_changed" && data) {
+          try {
+            onNotice(JSON.parse(data));
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  async search(req) {
+    const res = await fetch(`${this.apiUrl}/api/v1/search`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(req)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Cloud search failed: ${res.status} ${errText}`);
+    }
+    return await res.json();
+  }
+  async logoutDevice(deviceId) {
+    const res = await fetch(`${this.apiUrl}/api/v1/devices/logout`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ deviceId })
+    });
+    if (!res.ok) throw new Error(`Failed to log out device: ${res.status} ${await res.text()}`);
+    return await res.json();
+  }
+  async testConnection() {
+    try {
+      const res = await fetch(`${this.apiUrl}/api/v1/projects/resolve`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ slug: "__health_check__" })
+      });
+      return { ok: res.ok || res.status === 401 || res.status === 400, status: res.status };
+    } catch (err) {
+      return { ok: false, status: 0, message: err.message };
+    }
+  }
+};
+
+// src/outbox/db.ts
+import { DatabaseSync } from "node:sqlite";
+import path from "path";
+import fs from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+var OutboxDb = class {
+  db;
+  constructor(dbPath) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new DatabaseSync(dbPath);
+    this.init();
+  }
+  init() {
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec("PRAGMA synchronous = NORMAL;");
+    this.db.exec("PRAGMA busy_timeout = 5000;");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS outbox_events (
+        event_id TEXT PRIMARY KEY,
+        device_id TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        operation TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        payload_sha256 TEXT NOT NULL,
+        origin TEXT NOT NULL DEFAULT 'local',
+        attempts INTEGER NOT NULL DEFAULT 0,
+        next_attempt_at TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        acked_at TEXT,
+        last_error TEXT,
+        UNIQUE(device_id, sequence)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_outbox_due ON outbox_events(acked_at, next_attempt_at);
+      CREATE INDEX IF NOT EXISTS idx_outbox_project ON outbox_events(project_id, sequence);
+
+      CREATE TABLE IF NOT EXISTS sync_state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+  }
+  getLastSequence(deviceId) {
+    const stmt = this.db.prepare("SELECT MAX(sequence) as max_seq FROM outbox_events WHERE device_id = ?");
+    const row = stmt.get(deviceId);
+    return row?.max_seq ?? 0;
+  }
+  enqueueEvent(input2) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const eventId = input2.eventId || randomUUID2();
+    const payloadJson = JSON.stringify(input2.payload);
+    const payloadSha256 = sha256Hex(payloadJson);
+    const origin = input2.origin || "local";
+    const nextSeq = this.getLastSequence(input2.deviceId) + 1;
+    const stmt = this.db.prepare(`
+      INSERT INTO outbox_events (
+        event_id, device_id, project_id, sequence, operation,
+        payload_json, payload_sha256, origin, attempts,
+        next_attempt_at, created_at, acked_at, last_error
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, 0,
+        ?, ?, NULL, NULL
+      )
+    `);
+    stmt.run(
+      eventId,
+      input2.deviceId,
+      input2.projectId,
+      nextSeq,
+      input2.operation,
+      payloadJson,
+      payloadSha256,
+      origin,
+      now,
+      now
+    );
+    return {
+      eventId,
+      deviceId: input2.deviceId,
+      projectId: input2.projectId,
+      sequence: nextSeq,
+      operation: input2.operation,
+      payloadJson,
+      payloadSha256,
+      origin,
+      attempts: 0,
+      nextAttemptAt: now,
+      createdAt: now,
+      ackedAt: null,
+      lastError: null
+    };
+  }
+  getDueEvents(limit = 50, force = false) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sql = force ? `SELECT 
+          event_id as eventId,
+          device_id as deviceId,
+          project_id as projectId,
+          sequence,
+          operation,
+          payload_json as payloadJson,
+          payload_sha256 as payloadSha256,
+          origin,
+          attempts,
+          next_attempt_at as nextAttemptAt,
+          created_at as createdAt,
+          acked_at as ackedAt,
+          last_error as lastError
+        FROM outbox_events
+        WHERE acked_at IS NULL
+        ORDER BY sequence ASC
+        LIMIT ?` : `SELECT 
+          event_id as eventId,
+          device_id as deviceId,
+          project_id as projectId,
+          sequence,
+          operation,
+          payload_json as payloadJson,
+          payload_sha256 as payloadSha256,
+          origin,
+          attempts,
+          next_attempt_at as nextAttemptAt,
+          created_at as createdAt,
+          acked_at as ackedAt,
+          last_error as lastError
+        FROM outbox_events
+        WHERE acked_at IS NULL AND next_attempt_at <= ?
+        ORDER BY sequence ASC
+        LIMIT ?`;
+    const stmt = this.db.prepare(sql);
+    return force ? stmt.all(limit) : stmt.all(now, limit);
+  }
+  markAcked(eventIds) {
+    if (eventIds.length === 0) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const placeholders = eventIds.map(() => "?").join(",");
+    const stmt = this.db.prepare(`
+      UPDATE outbox_events
+      SET acked_at = ?
+      WHERE event_id IN (${placeholders})
+    `);
+    stmt.run(now, ...eventIds);
+  }
+  recordFailure(eventId, errorMessage) {
+    const stmt = this.db.prepare("SELECT attempts FROM outbox_events WHERE event_id = ?");
+    const record = stmt.get(eventId);
+    if (!record) return;
+    const newAttempts = record.attempts + 1;
+    const delaySeconds = Math.min(300, Math.pow(2, Math.min(newAttempts, 8))) + Math.random() * 2;
+    const nextAttempt = new Date(Date.now() + delaySeconds * 1e3).toISOString();
+    const updateStmt = this.db.prepare(`
+      UPDATE outbox_events
+      SET attempts = ?, next_attempt_at = ?, last_error = ?
+      WHERE event_id = ?
+    `);
+    updateStmt.run(newAttempts, nextAttempt, errorMessage.slice(0, 500), eventId);
+  }
+  getPendingCount() {
+    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM outbox_events WHERE acked_at IS NULL");
+    const row = stmt.get();
+    return row.count;
+  }
+  getAllEvents(limit = 100) {
+    const stmt = this.db.prepare(`
+      SELECT 
+        event_id as eventId,
+        device_id as deviceId,
+        project_id as projectId,
+        sequence,
+        operation,
+        payload_json as payloadJson,
+        payload_sha256 as payloadSha256,
+        origin,
+        attempts,
+        next_attempt_at as nextAttemptAt,
+        created_at as createdAt,
+        acked_at as ackedAt,
+        last_error as lastError
+      FROM outbox_events
+      ORDER BY sequence DESC
+      LIMIT ?
+    `);
+    return stmt.all(limit);
+  }
+  getState(key) {
+    const stmt = this.db.prepare("SELECT value FROM sync_state WHERE key = ?");
+    const row = stmt.get(key);
+    return row?.value ?? null;
+  }
+  setState(key, value) {
+    const stmt = this.db.prepare(`
+      INSERT INTO sync_state (key, value) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `);
+    stmt.run(key, value);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/project-resolver.ts
+import { execSync } from "child_process";
+import path2 from "path";
+import fs2 from "fs";
+function sanitizeSlug(input2) {
+  return input2.toLowerCase().trim().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "default-project";
+}
+function detectGitRemote(cwd = process.cwd()) {
+  try {
+    const output2 = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    if (output2) return output2;
+  } catch {
+  }
+  return void 0;
+}
+function extractSlugFromGitRemote(remoteUrl) {
+  try {
+    const cleaned = remoteUrl.replace(/\.git$/, "").trim();
+    const parts = cleaned.split(/[/:]/);
+    if (parts.length >= 2) {
+      const repo = parts[parts.length - 1];
+      const owner = parts[parts.length - 2];
+      if (repo && owner && !owner.includes("@") && !owner.includes("//")) {
+        return sanitizeSlug(`${owner}-${repo}`);
+      }
+      if (repo) {
+        return sanitizeSlug(repo);
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function detectPackageName(cwd = process.cwd()) {
+  try {
+    const pkgPath = path2.join(cwd, "package.json");
+    if (fs2.existsSync(pkgPath)) {
+      const content = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      if (content.name && typeof content.name === "string") {
+        return sanitizeSlug(content.name.replace(/^@[^/]+\//, ""));
+      }
+    }
+  } catch {
+  }
+  try {
+    const pyprojectPath = path2.join(cwd, "pyproject.toml");
+    if (fs2.existsSync(pyprojectPath)) {
+      const content = fs2.readFileSync(pyprojectPath, "utf8");
+      const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+      if (match && match[1]) {
+        return sanitizeSlug(match[1]);
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function detectProjectContext(cwd = process.cwd()) {
+  const gitRemote = detectGitRemote(cwd);
+  let slug;
+  let name;
+  if (gitRemote) {
+    slug = extractSlugFromGitRemote(gitRemote);
+  }
+  if (!slug) {
+    slug = detectPackageName(cwd);
+  }
+  if (!slug) {
+    const dirName = path2.basename(path2.resolve(cwd));
+    slug = sanitizeSlug(dirName);
+    name = dirName;
+  } else {
+    name = slug.replace(/[-_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+  }
+  return {
+    slug,
+    name: name || slug,
+    gitRemote,
+    workingDir: cwd
+  };
+}
+
+// src/proxy/server.ts
+var MemHubMcpServer = class {
+  server;
+  localEngine;
+  syncEngine;
+  outboxDb;
+  cloudClient;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.outboxDb = new OutboxDb(config.outboxPath);
+    this.cloudClient = new CloudApiClient(config.apiUrl, config.apiKey);
+    this.localEngine = new LocalAgentMemoryEngine();
+    const localProject = detectProjectContext();
+    const effectiveProjectId = config.projectId || config.projectSlug || localProject.slug;
+    this.syncEngine = new SyncEngine({
+      outboxDb: this.outboxDb,
+      cloudClient: this.cloudClient,
+      deviceId: config.deviceId,
+      projectId: effectiveProjectId,
+      orgId: config.orgId,
+      onRemoteEventsReceived: async (events) => {
+        await this.localEngine.importRemoteEvents(events);
+      }
+    });
+    this.server = new Server(
+      {
+        name: "memhub-mcp",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const nativeTools = this.localEngine.getToolList();
+      const memhubTools = [
+        {
+          name: "memhub_sync_status",
+          description: "Checks synchronization status, pending outbox count, device ID, and cloud connectivity.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "memhub_sync_now",
+          description: "Forces an immediate on-demand push of all pending outbox events and pulls latest team deltas.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "memhub_cloud_search",
+          description: "Searches the organization aggregated memory corpus directly in the cloud (FTS + vector).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query" },
+              limit: { type: "number", description: "Max results to return" },
+              mode: { type: "string", enum: ["fts", "vector", "hybrid"], description: "Search mode" }
+            },
+            required: ["query"]
+          }
+        }
+      ];
+      return {
+        tools: [...nativeTools, ...memhubTools]
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args = {} } = request.params;
+      try {
+        if (name === "memhub_sync_status") {
+          const status = this.syncEngine.getStatus();
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(status, null, 2)
+            }]
+          };
+        }
+        if (name === "memhub_sync_now") {
+          const [pushResult, pullResult] = await Promise.allSettled([
+            this.syncEngine.triggerPushOnDemand(),
+            this.syncEngine.triggerPullOnDemand()
+          ]);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                push: pushResult.status === "fulfilled" ? pushResult.value : { error: pushResult.reason?.message },
+                pull: pullResult.status === "fulfilled" ? pullResult.value : { error: pullResult.reason?.message },
+                status: this.syncEngine.getStatus()
+              }, null, 2)
+            }]
+          };
+        }
+        if (name === "memhub_cloud_search") {
+          try {
+            const results = await this.cloudClient.search({
+              query: String(args.query || ""),
+              limit: Number(args.limit || 10),
+              mode: args.mode || "hybrid"
+            });
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify(results, null, 2)
+              }]
+            };
+          } catch (err) {
+            const fallback = await this.localEngine.executeTool("memory_recall", {
+              query: args.query,
+              limit: args.limit
+            });
+            return {
+              content: [{
+                type: "text",
+                text: `[Cloud search degraded: ${err.message}. Showing local results:]
+` + fallback.content[0].text
+              }]
+            };
+          }
+        }
+        if (name === "memory_recall" || name === "mem_search" || name === "memory_session_start" || name === "mem_session_start") {
+          this.syncEngine.refreshIfStale();
+        }
+        const result = await this.localEngine.executeTool(name, args);
+        if (MUTATING_TOOLS.has(name)) {
+          let op = "memory.save";
+          if (name === "memory_delete" || name === "memory_governance_delete") op = "memory.delete";
+          else if (name === "mem_pin") op = "memory.pin";
+          else if (name === "mem_unpin") op = "memory.unpin";
+          else if (name.includes("session_summary")) op = "session.summary";
+          await this.syncEngine.handleLocalMutation(op, {
+            tool: name,
+            title: args.title,
+            content: args.content || args.summary,
+            memoryType: args.type || "observation",
+            topicKey: args.topic_key,
+            isPinned: Boolean(args.is_pinned),
+            arguments: args
+          });
+        }
+        return result;
+      } catch (err) {
+        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${err.message}`);
+      }
+    });
+  }
+  async start() {
+    await this.localEngine.initialize();
+    if (this.config.apiKey) {
+      try {
+        const localCtx = detectProjectContext();
+        const resolved = await this.cloudClient.resolveProject({
+          slug: this.config.projectSlug || localCtx.slug,
+          gitRemote: localCtx.gitRemote,
+          name: localCtx.name
+        });
+        this.syncEngine.setProjectId(resolved.projectId);
+        this.syncEngine.setOrgId(resolved.orgId);
+        await this.syncEngine.startAutomaticSync();
+      } catch (err) {
+      }
+    }
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+  getOutboxDb() {
+    return this.outboxDb;
+  }
+  getSyncEngine() {
+    return this.syncEngine;
+  }
+};
+
+// src/config.ts
+import fs3 from "fs";
+import path3 from "path";
+import os from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+import dotenv from "dotenv";
+dotenv.config();
+function defaultStorageDir() {
+  return path3.join(os.homedir(), ".memhub");
+}
+function resolveStorageDir() {
+  return process.env.MEMHUB_DIR || process.env.TEAMCONTEXT_DIR || defaultStorageDir();
+}
+function legacyStorageDir() {
+  return path3.join(os.homedir(), ".teamcontext");
+}
+function configFile(dir) {
+  return path3.join(dir, "config.json");
+}
+var IS_POSIX = process.platform !== "win32";
+function ensureDirectory(dir) {
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  if (IS_POSIX) {
+    try {
+      fs3.chmodSync(dir, 448);
+    } catch {
+    }
+  }
+}
+function envPreferred(name) {
+  return process.env[name] || process.env[name.replace(/^MEMHUB_/, "TEAMCONTEXT_")];
+}
+function loadSavedConfig() {
+  const paths = [configFile(defaultStorageDir()), configFile(legacyStorageDir())];
+  for (const file of paths) {
+    try {
+      if (fs3.existsSync(file)) {
+        return JSON.parse(fs3.readFileSync(file, "utf8"));
+      }
+    } catch (err) {
+    }
+  }
+  return {};
+}
+function saveConfig(updates) {
+  const dir = resolveStorageDir();
+  ensureDirectory(dir);
+  const current = loadSavedConfig();
+  const merged = { ...current, ...updates };
+  const file = configFile(dir);
+  fs3.writeFileSync(file, JSON.stringify(merged, null, 2), { encoding: "utf8", mode: 384 });
+  if (IS_POSIX) {
+    try {
+      fs3.chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function clearLocalState() {
+  const saved = loadSavedConfig();
+  const dir = resolveStorageDir();
+  const files = new Set([
+    configFile(dir),
+    saved.outboxPath,
+    envPreferred("MEMHUB_OUTBOX_PATH"),
+    path3.join(dir, "outbox.db")
+  ].filter((value) => Boolean(value)));
+  for (const file of files) {
+    for (const candidate of [file, `${file}-wal`, `${file}-shm`]) {
+      try {
+        if (fs3.existsSync(candidate)) fs3.unlinkSync(candidate);
+      } catch {
+      }
+    }
+  }
+}
+function getOrCreateDeviceId() {
+  const saved = loadSavedConfig();
+  if (saved.deviceId && saved.deviceId.length > 10) {
+    return saved.deviceId;
+  }
+  const newDeviceId = randomUUID3();
+  saveConfig({ deviceId: newDeviceId });
+  return newDeviceId;
+}
+function getConfig() {
+  const saved = loadSavedConfig();
+  const storageDir = resolveStorageDir();
+  ensureDirectory(storageDir);
+  const deviceId = envPreferred("MEMHUB_DEVICE_ID") || saved.deviceId || getOrCreateDeviceId();
+  const apiUrl = envPreferred("MEMHUB_API_URL") || saved.apiUrl || "https://memhub.simplex.lat";
+  const apiKey = envPreferred("MEMHUB_API_KEY") || saved.apiKey;
+  const projectId = envPreferred("MEMHUB_PROJECT_ID") || saved.projectId;
+  const projectSlug = envPreferred("MEMHUB_PROJECT") || saved.projectSlug;
+  const orgId = envPreferred("MEMHUB_ORG_ID") || saved.orgId;
+  const outboxPath = envPreferred("MEMHUB_OUTBOX_PATH") || path3.join(storageDir, "outbox.db");
+  return {
+    apiUrl: apiUrl.replace(/\/$/, ""),
+    apiKey,
+    projectId,
+    projectSlug,
+    orgId,
+    deviceId,
+    outboxPath,
+    storageDir
+  };
+}
+
+// src/connectors/ide-injector.ts
+import fs4 from "fs";
+import path4 from "path";
+import os2 from "os";
+var IdeConfigInjector = class {
+  static serverConfig() {
+    return { command: "memhub", args: ["serve"] };
+  }
+  static injectJsonMcpConfig(target, configPath, options) {
+    try {
+      const parent = path4.dirname(configPath);
+      if (!fs4.existsSync(parent) && !options.dryRun) fs4.mkdirSync(parent, { recursive: true });
+      let config = { mcpServers: {} };
+      if (fs4.existsSync(configPath)) config = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      config.mcpServers = config.mcpServers || {};
+      config.mcpServers.memhub = this.serverConfig();
+      const existed = fs4.existsSync(configPath);
+      if (!options.dryRun) fs4.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+      return { target, filePath: configPath, success: true, action: existed ? "updated" : "created" };
+    } catch (err) {
+      return { target, filePath: configPath, success: false, action: "error", error: err.message };
+    }
+  }
+  /**
+   * Injects config for Claude Code (`mcp.json` or `~/.claude/mcp.json`)
+   */
+  static injectClaudeCode(options) {
+    const cwd = options.cwd || process.cwd();
+    const configPath = path4.join(cwd, "mcp.json");
+    try {
+      let config = { mcpServers: {} };
+      if (fs4.existsSync(configPath)) {
+        config = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      }
+      config.mcpServers = config.mcpServers || {};
+      config.mcpServers.memhub = this.serverConfig();
+      if (!options.dryRun) {
+        fs4.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+      }
+      return {
+        target: "Claude Code",
+        filePath: configPath,
+        success: true,
+        action: fs4.existsSync(configPath) ? "updated" : "created"
+      };
+    } catch (err) {
+      return {
+        target: "Claude Code",
+        filePath: configPath,
+        success: false,
+        action: "error",
+        error: err.message
+      };
+    }
+  }
+  /**
+   * Injects config for Cursor (`.cursor/mcp.json`)
+   */
+  static injectCursor(options) {
+    const cwd = options.cwd || process.cwd();
+    const cursorDir = path4.join(cwd, ".cursor");
+    const configPath = path4.join(cursorDir, "mcp.json");
+    try {
+      if (!fs4.existsSync(cursorDir) && !options.dryRun) {
+        fs4.mkdirSync(cursorDir, { recursive: true });
+      }
+      let config = { mcpServers: {} };
+      if (fs4.existsSync(configPath)) {
+        config = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      }
+      config.mcpServers = config.mcpServers || {};
+      config.mcpServers.memhub = this.serverConfig();
+      if (!options.dryRun) {
+        fs4.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+      }
+      return {
+        target: "Cursor",
+        filePath: configPath,
+        success: true,
+        action: fs4.existsSync(configPath) ? "updated" : "created"
+      };
+    } catch (err) {
+      return {
+        target: "Cursor",
+        filePath: configPath,
+        success: false,
+        action: "error",
+        error: err.message
+      };
+    }
+  }
+  /** Google Antigravity 2.0 / IDE / CLI shared global MCP configuration. */
+  static injectAntigravity(options) {
+    return this.injectJsonMcpConfig(
+      "Google Antigravity",
+      path4.join(os2.homedir(), ".gemini", "config", "mcp_config.json"),
+      options
+    );
+  }
+  /** Windsurf Cascade global MCP configuration. */
+  static injectWindsurf(options) {
+    return this.injectJsonMcpConfig(
+      "Windsurf",
+      path4.join(os2.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+      options
+    );
+  }
+  /** Cline global MCP configuration shared by its IDE and CLI clients. */
+  static injectCline(options) {
+    return this.injectJsonMcpConfig(
+      "Cline",
+      path4.join(os2.homedir(), ".cline", "data", "settings", "cline_mcp_settings.json"),
+      options
+    );
+  }
+  /** Generic JSON client using the common { mcpServers: {} } format. */
+  static injectOther(configPath, options) {
+    return this.injectJsonMcpConfig("Other MCP client", path4.resolve(configPath), options);
+  }
+  /**
+   * Injects config for Codex CLI (`config.toml` or `~/.codex/config.toml`)
+   */
+  static injectCodex(options) {
+    const codexDir = path4.join(os2.homedir(), ".codex");
+    const configPath = path4.join(codexDir, "config.toml");
+    try {
+      if (!fs4.existsSync(codexDir) && !options.dryRun) {
+        fs4.mkdirSync(codexDir, { recursive: true });
+      }
+      const entry = `
+# MemHub MCP Connector
+[mcp.servers.memhub]
+command = "memhub"
+args = ["serve"]
+`;
+      let content = "";
+      if (fs4.existsSync(configPath)) {
+        content = fs4.readFileSync(configPath, "utf8");
+      }
+      if (!content.includes("[mcp.servers.memhub]")) {
+        content += entry;
+        if (!options.dryRun) {
+          fs4.writeFileSync(configPath, content, "utf8");
+        }
+      }
+      return {
+        target: "Codex CLI",
+        filePath: configPath,
+        success: true,
+        action: "updated"
+      };
+    } catch (err) {
+      return {
+        target: "Codex CLI",
+        filePath: configPath,
+        success: false,
+        action: "error",
+        error: err.message
+      };
+    }
+  }
+  /**
+   * Injects for all supported IDEs and tools
+   */
+  static injectAll(options) {
+    return [
+      this.injectClaudeCode(options),
+      this.injectCursor(options),
+      this.injectCodex(options),
+      this.injectAntigravity(options),
+      this.injectWindsurf(options),
+      this.injectCline(options)
+    ];
+  }
+};
+
+// src/cli.ts
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { hostname } from "node:os";
+
+// src/auth/login-flow.ts
+import { spawn } from "node:child_process";
+var LoginDeniedError = class extends Error {
+  constructor() {
+    super("Login request denied in the browser.");
+    this.name = "LoginDeniedError";
+  }
+};
+var LoginExpiredError = class extends Error {
+  constructor() {
+    super("Login request expired before approval. Run `mh login` again.");
+    this.name = "LoginExpiredError";
+  }
+};
+var LoginTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Login was not approved within ${Math.round(timeoutMs / 1e3)}s. Run \`mh login\` again.`);
+    this.name = "LoginTimeoutError";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 15 * 60 * 1e3;
+var MIN_SLEEP_MS = 250;
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestCliAuth(apiUrl, options = {}) {
+  const doFetch = options.fetchImpl ?? fetch;
+  const res = await doFetch(`${apiUrl}/api/cli-auth/initiate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ label: options.label, scopes: options.scopes })
+  });
+  if (!res.ok) {
+    throw new Error(`Unable to start login (${res.status}). Check that ${apiUrl} is reachable.`);
+  }
+  return await res.json();
+}
+async function pollOnce(apiUrl, deviceCode, doFetch) {
+  const res = await doFetch(`${apiUrl}/api/cli-auth/poll`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ deviceCode })
+  });
+  if (res.status === 429) {
+    const retryAfter = Number(res.headers.get("retry-after"));
+    return {
+      result: { status: "pending", expiresAt: null },
+      retryAfterSeconds: Number.isFinite(retryAfter) && retryAfter > 0 ? Math.ceil(retryAfter) : null
+    };
+  }
+  if (!res.ok) throw new Error(`Login polling failed (${res.status}).`);
+  return { result: await res.json(), retryAfterSeconds: null };
+}
+async function waitForCliApproval(apiUrl, initiation, options = {}) {
+  const doFetch = options.fetchImpl ?? fetch;
+  const sleep = options.sleepImpl ?? defaultSleep;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  let pendingNoticeShown = false;
+  while (Date.now() < deadline) {
+    const { result, retryAfterSeconds } = await pollOnce(apiUrl, initiation.deviceCode, doFetch);
+    if (result.status === "approved") {
+      if (!result.apiKey) throw new Error("Server returned an empty credential.");
+      return {
+        apiKey: result.apiKey,
+        keyPrefix: result.keyPrefix,
+        orgSlug: result.orgSlug,
+        orgName: result.orgName,
+        projectSlug: result.projectSlug,
+        projectName: result.projectName
+      };
+    }
+    if (result.status === "denied") throw new LoginDeniedError();
+    if (result.status === "consumed" || result.status === "not_found") throw new LoginExpiredError();
+    if (!pendingNoticeShown) {
+      process.stderr.write("\u23F3 Waiting for approval in your browser\u2026\n");
+      pendingNoticeShown = true;
+    }
+    const intervalMs = Math.max((initiation.pollIntervalSeconds || 2) * 1e3, MIN_SLEEP_MS);
+    const backoffMs = retryAfterSeconds ? Math.min(retryAfterSeconds * 1e3, 3e4) : intervalMs;
+    const remainingMs = deadline - Date.now();
+    await sleep(Math.max(MIN_SLEEP_MS, Math.min(backoffMs, remainingMs)));
+  }
+  throw new LoginTimeoutError(timeoutMs);
+}
+function browserOpenCommand(platform = process.platform) {
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  return command === "cmd" ? { command, args: ["/c", "start", "", "<url>"] } : { command, args: ["<url>"] };
+}
+function openInBrowser(url) {
+  try {
+    const { command, args } = browserOpenCommand();
+    const child = spawn(command, args.map((arg) => arg === "<url>" ? url : arg), { stdio: "ignore", detached: true });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+var supportedTargets = ["claude", "cursor", "windsurf", "cline", "codex", "antigravity"];
+async function selectInstallTargets(value, otherConfig) {
+  if (value) {
+    const requested = value.toLowerCase().split(",").map((item) => item.trim()).filter(Boolean);
+    const expanded = requested.includes("all") ? [...supportedTargets] : requested;
+    const invalid = expanded.filter((item) => !supportedTargets.includes(item) && item !== "other");
+    if (invalid.length) throw new Error(`Unsupported IDE target(s): ${invalid.join(", ")}`);
+    if (expanded.includes("other") && !otherConfig) throw new Error("--config <path> is required with --ide other");
+    return [...new Set(expanded)];
+  }
+  if (!input.isTTY || !output.isTTY) return [...supportedTargets];
+  const rl = createInterface({ input, output });
+  output.write("\nWhere should MemHub be installed? Select one or more (comma-separated):\n");
+  output.write("  1) Claude Code\n  2) Cursor\n  3) Windsurf\n  4) Cline\n  5) Codex CLI\n  6) Google Antigravity\n  7) All supported clients\n  8) Other JSON MCP client\n");
+  const answer = await rl.question("Selection [7]: ");
+  rl.close();
+  const choices = (answer.trim() || "7").split(",").map((item) => item.trim());
+  if (choices.includes("7")) return [...supportedTargets];
+  const map = { "1": "claude", "2": "cursor", "3": "windsurf", "4": "cline", "5": "codex", "6": "antigravity", "8": "other" };
+  const selected = choices.map((choice) => map[choice]).filter(Boolean);
+  if (!selected.length) throw new Error("No valid installation target selected");
+  if (selected.includes("other") && !otherConfig) throw new Error("Use --config <path> when selecting Other");
+  return [...new Set(selected)];
+}
+async function installToSelectedClients(options) {
+  const targets = await selectInstallTargets(options.ide, options.configPath);
+  console.log(`\u{1F527} Injecting MCP server configuration for: ${targets.join(", ")}...`);
+  const injectOpts = {
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    projectId: options.projectSlug
+  };
+  const results = [];
+  for (const target of targets) {
+    if (target === "claude") results.push(IdeConfigInjector.injectClaudeCode(injectOpts));
+    if (target === "cursor") results.push(IdeConfigInjector.injectCursor(injectOpts));
+    if (target === "windsurf") results.push(IdeConfigInjector.injectWindsurf(injectOpts));
+    if (target === "cline") results.push(IdeConfigInjector.injectCline(injectOpts));
+    if (target === "codex") results.push(IdeConfigInjector.injectCodex(injectOpts));
+    if (target === "antigravity") results.push(IdeConfigInjector.injectAntigravity(injectOpts));
+    if (target === "other") results.push(IdeConfigInjector.injectOther(options.configPath, injectOpts));
+  }
+  for (const res of results) {
+    if (res.success) {
+      console.log(`  \u2713 ${res.target}: configured at ${res.filePath}`);
+    } else {
+      console.log(`  \u2717 ${res.target}: failed (${res.error})`);
+    }
+  }
+}
+program.name("memhub").description("Local-first MCP proxy for MemHub & agentmemory").version("0.1.0");
+program.command("serve").description("Start the MemHub MCP stdio proxy server").action(async () => {
+  const config = getConfig();
+  const server = new MemHubMcpServer(config);
+  await server.start();
+});
+program.command("install [target]").description("Install the global MemHub MCP server into an AI client (or use generic)").option("--config <path>", "JSON MCP config path for a generic/other client").action(async (target, options) => {
+  const config = getConfig();
+  if (!config.apiKey) {
+    console.error("No MemHub session is configured. Run `memhub login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  if (target === "generic" && !options.config) {
+    console.log(JSON.stringify({
+      mcpServers: { memhub: { command: "memhub", args: ["serve"] } }
+    }, null, 2));
+    return;
+  }
+  await installToSelectedClients({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl,
+    projectSlug: config.projectSlug || detectProjectContext().slug,
+    ide: target === "generic" ? "other" : target,
+    configPath: options.config
+  });
+});
+program.command("connect").description("Connect the current repository or workspace to MemHub Cloud").requiredOption("-k, --key <apiKey>", "MemHub API Key (e.g. mh_live_...)").option("-u, --url <apiUrl>", "MemHub Cloud API URL", "https://memhub.simplex.lat").option("-p, --project <projectSlug>", "Override project slug").option("--ide <ides>", "Comma-separated targets: all, claude, cursor, windsurf, cline, codex, antigravity, other").option("--config <path>", "JSON MCP config path when using --ide other").action(async (options) => {
+  console.log("\u{1F680} Connecting to MemHub Cloud...");
+  const detected = detectProjectContext();
+  const projectSlug = options.project || detected.slug;
+  saveConfig({
+    apiKey: options.key,
+    apiUrl: options.url,
+    projectSlug
+  });
+  const client = new CloudApiClient(options.url, options.key);
+  console.log(`\u{1F4E1} Resolving project "${projectSlug}" on cloud...`);
+  try {
+    const resolved = await client.resolveProject({
+      slug: projectSlug,
+      gitRemote: detected.gitRemote,
+      name: detected.name
+    });
+    console.log(`\u2705 Project resolved: ${resolved.projectName} (ID: ${resolved.projectId}, Org: ${resolved.orgSlug})`);
+    saveConfig({
+      projectId: resolved.projectId,
+      orgId: resolved.orgId
+    });
+  } catch (err) {
+    console.warn(`\u26A0\uFE0F Cloud project resolution warning: ${err.message}`);
+    console.log("   (Local memory and offline outbox will continue to work normally)");
+  }
+  await installToSelectedClients({
+    apiKey: options.key,
+    apiUrl: options.url,
+    projectSlug,
+    ide: options.ide,
+    configPath: options.config
+  });
+  console.log("\n\u{1F389} MemHub MCP proxy successfully connected!");
+  console.log("   Restart or refresh the selected AI clients to load MemHub.");
+});
+program.command("login").description("Sign in with your browser, consent to a scoped project credential, then pick AI clients to configure").option("-u, --url <apiUrl>", "MemHub Cloud API URL", "https://memhub.simplex.lat").option("--ide <ides>", "Comma-separated targets: all, claude, cursor, windsurf, cline, codex, antigravity, other").option("--config <path>", "JSON MCP config path when using --ide other").option("--label <label>", "Device label shown on the consent page").option("--no-open", "Print the verification URL instead of opening a browser").action(async (options) => {
+  try {
+    console.log("\u{1F510} Starting browser login for MemHub Cloud...");
+    const initiation = await requestCliAuth(options.url, {
+      label: options.label || `${hostname()} terminal`
+    });
+    const opened = options.open ? openInBrowser(initiation.verificationUrl) : false;
+    if (!opened) {
+      console.log("\n\u{1F310} Open this URL in any browser to continue:");
+      console.log(`   ${initiation.verificationUrl}`);
+    } else {
+      console.log(`
+\u{1F310} Browser opened at ${options.url}/cli-auth \u2014 sign in, review the request, and approve.`);
+    }
+    console.log("\u23F1\uFE0F  The login request expires in 15 minutes and can be approved only once.");
+    const approval = await waitForCliApproval(options.url, initiation);
+    saveConfig({
+      apiKey: approval.apiKey,
+      apiUrl: options.url,
+      projectSlug: approval.projectSlug ?? void 0
+    });
+    console.log(`\u2705 Signed in${approval.orgName ? ` to ${approval.orgName}` : ""}. Scoped credential ${approval.keyPrefix}\u2026 saved to ~/.memhub/config.json (owner-only).`);
+    if (!approval.projectSlug) {
+      console.log("\u2139\uFE0F  No default project was chosen during consent; it will be resolved per-repository on first use.");
+    }
+    await installToSelectedClients({
+      apiKey: approval.apiKey,
+      apiUrl: options.url,
+      projectSlug: approval.projectSlug || detectProjectContext().slug,
+      ide: options.ide,
+      configPath: options.config
+    });
+    console.log("\n\u{1F389} Login complete! Restart or refresh the selected AI clients to load MemHub.");
+  } catch (err) {
+    if (err instanceof LoginDeniedError) {
+      console.error("\u2717 Login denied in the browser. No credentials were stored.");
+    } else if (err instanceof LoginExpiredError || err instanceof LoginTimeoutError) {
+      console.error(`\u2717 ${err.message}`);
+    } else {
+      console.error(`\u2717 Login failed: ${err.message}`);
+    }
+    process.exitCode = 1;
+  }
+});
+program.command("logout").description("Revoke this device, release its plan slot, and remove local MemHub credentials and sync state").option("--local-only", "Clear local state even when the cloud cannot be reached").action(async (options) => {
+  const config = getConfig();
+  if (!config.apiKey && !options.localOnly) {
+    console.error("No MemHub session is configured on this device.");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    if (config.apiKey && !options.localOnly) {
+      const result = await new CloudApiClient(config.apiUrl, config.apiKey).logoutDevice(config.deviceId);
+      console.log(result.deviceReleased ? "\u2713 Device revoked and its plan slot released." : "\u2713 Credential revoked; this device had no active cloud slot.");
+    }
+    clearLocalState();
+    console.log("\u2713 Local MemHub credentials and sync outbox removed. Cloud memory history was preserved.");
+    console.log("  Restart configured AI clients. Run mh login to connect again.");
+  } catch (err) {
+    console.error(`\u2717 Logout failed: ${err.message}`);
+    console.error("  Local credentials were kept so you can retry. Use --local-only only if this device cannot reach MemHub.");
+    process.exitCode = 1;
+  }
+});
+program.command("status").description("Display synchronization status, outbox stats, and device info").action(async () => {
+  const config = getConfig();
+  const db = new OutboxDb(config.outboxPath);
+  const pendingCount = db.getPendingCount();
+  const lastSeq = db.getLastSequence(config.deviceId);
+  const localProject = detectProjectContext();
+  console.log("\n\u{1F4CA} MemHub MCP Status:");
+  console.log(`  Device ID:          ${config.deviceId}`);
+  console.log(`  API URL:            ${config.apiUrl}`);
+  console.log(`  API Key:            ${config.apiKey ? config.apiKey.slice(0, 12) + "..." : "(none configured)"}`);
+  console.log(`  Project Slug:       ${config.projectSlug || localProject.slug}`);
+  console.log(`  Project ID:         ${config.projectId || "(pending JIT resolution)"}`);
+  console.log(`  Outbox SQLite DB:   ${config.outboxPath}`);
+  console.log(`  Pending Events:     ${pendingCount}`);
+  console.log(`  Monotonic Sequence: ${lastSeq}`);
+  db.close();
+});
+program.command("doctor").description("Run system health checks and diagnostics for local engine & cloud sync").action(async () => {
+  console.log("\n\u{1FA7A} Running MemHub Doctor...\n");
+  const config = getConfig();
+  console.log("1. Checking local engine tools:");
+  console.log(`   \u2713 Found ${AGENTMEMORY_54_TOOLS.length} native agentmemory tools mapped.`);
+  console.log("2. Checking local durable outbox (WAL mode):");
+  try {
+    const db = new OutboxDb(config.outboxPath);
+    const pending = db.getPendingCount();
+    console.log(`   \u2713 Outbox SQLite database accessible (${pending} pending events).`);
+    db.close();
+  } catch (err) {
+    console.log(`   \u2717 Outbox error: ${err.message}`);
+  }
+  console.log("3. Checking MemHub Cloud API connectivity:");
+  if (!config.apiKey) {
+    console.log("   \u26A0\uFE0F No API key configured. Run `memhub login` or `memhub connect --key <key>`.");
+  } else {
+    const client = new CloudApiClient(config.apiUrl, config.apiKey);
+    const health = await client.testConnection();
+    if (health.ok) {
+      console.log(`   \u2713 Cloud API reachable at ${config.apiUrl} (HTTP status: ${health.status})`);
+    } else {
+      console.log(`   \u2717 Cloud API unreachable at ${config.apiUrl} (${health.message})`);
+    }
+  }
+  console.log("\nDoctor inspection completed.");
+});
+program.command("flush").description("Force an immediate push of all pending outbox events to the cloud").action(async () => {
+  const config = getConfig();
+  if (!config.apiKey) {
+    console.error("Error: No API key configured. Run connect first.");
+    process.exit(1);
+  }
+  console.log("\u{1F504} Flushing pending outbox events to cloud...");
+  const db = new OutboxDb(config.outboxPath);
+  const client = new CloudApiClient(config.apiUrl, config.apiKey);
+  const dueEvents = db.getDueEvents(100);
+  if (dueEvents.length === 0) {
+    console.log("\u2713 Outbox is already clean (0 pending events).");
+    db.close();
+    return;
+  }
+  try {
+    const res = await client.pushEvents({
+      protocol: 1,
+      deviceId: config.deviceId,
+      events: dueEvents.map((e) => ({
+        eventId: e.eventId,
+        sequence: e.sequence,
+        operation: e.operation,
+        payload: JSON.parse(e.payloadJson),
+        payloadSha256: e.payloadSha256
+      }))
+    });
+    if (res.ackedEventIds && res.ackedEventIds.length > 0) {
+      db.markAcked(res.ackedEventIds);
+      console.log(`\u2705 Successfully flushed and acked ${res.ackedEventIds.length} events.`);
+    }
+  } catch (err) {
+    console.error(`\u2717 Flush failed: ${err.message}`);
+  } finally {
+    db.close();
+  }
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map