@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/v2/server-w99cyt6a.js

@@ -0,0 +1,361 @@
+import {
+  harnessOwnsOpenCodeStore,
+  log
+} from "./server-ckpc8pxy.js";
+import {
+  resolveOpenCodeDbPath,
+  assertOpenCodeStoreGeneration,
+  openCodeDbPathExists,
+  recordOpenCodeDbReadFailure,
+  clearOpenCodeDbReadFailure,
+  claimOpenCodeDbDiagnosticOnce,
+  closeQuietly
+} from "./server-qpg6wf72.js";
+import {
+  Database
+} from "./server-a4m2b1yv.js";
+
+// src/hooks/magic-context/read-session-db.ts
+function openCodeDbExists() {
+  return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
+}
+var cachedReadOnlyDb = null;
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  if (!harnessOwnsOpenCodeStore()) {
+    throw new Error("OpenCode session database is not readable from a Pi-compatible process; its history lives in Pi sessions");
+  }
+  const resolution = resolveOpenCodeDbPath();
+  const dbPath = resolution.path;
+  if (!openCodeDbPathExists(resolution)) {
+    throw new Error(`OpenCode session database is unavailable at ${dbPath} (source=${resolution.source})`);
+  }
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+  } catch (error) {
+    closeQuietly(db);
+    throw error;
+  }
+  cachedReadOnlyDb = { path: dbPath, db };
+  clearOpenCodeDbReadFailure();
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
+             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+var trackedSessions = new Map;
+var pendingParts = new Map;
+var probeLogObserverForTests;
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function truthyStoredFlag(value) {
+  return value === true || value === 1 || value === "true";
+}
+function isMachineGeneratedPart(value) {
+  const part = asRecord(value);
+  if (!part)
+    return false;
+  const metadata = asRecord(part.metadata);
+  const marker = asRecord(metadata?.marker);
+  return truthyStoredFlag(part.synthetic) || truthyStoredFlag(part.ignored) || marker !== null && marker.kind !== null && marker.kind !== undefined;
+}
+function messageTimeCreated(message, fallback) {
+  const time = asRecord(message.info.time);
+  return typeof time?.created === "number" ? time.created : fallback;
+}
+function latestMessageByRole(messages, role, realUserOnly = false) {
+  let latest = null;
+  for (const [index, message] of messages.entries()) {
+    if (message.info.role !== role)
+      continue;
+    if (realUserOnly && message.parts.length > 0 && message.parts.every(isMachineGeneratedPart)) {
+      continue;
+    }
+    const timeCreated = messageTimeCreated(message, index);
+    if (latest === null || timeCreated > latest.timeCreated || timeCreated === latest.timeCreated && index > latest.index) {
+      latest = { message, timeCreated, index };
+    }
+  }
+  return latest;
+}
+function assistantAwaitingToolsFromMessages(messages) {
+  const latestAssistant = latestMessageByRole(messages, "assistant");
+  if (!latestAssistant)
+    return false;
+  const assistantTime = asRecord(latestAssistant.message.info.time);
+  if (typeof assistantTime?.created !== "number")
+    return false;
+  const latestRealUser = latestMessageByRole(messages, "user", true);
+  if (latestRealUser && latestRealUser.timeCreated > latestAssistant.timeCreated)
+    return false;
+  if (latestAssistant.message.info.finish === "tool-calls")
+    return true;
+  return latestAssistant.message.parts.some((value) => {
+    const part = asRecord(value);
+    return part?.type === "tool" && part.providerExecuted !== true;
+  });
+}
+function shouldHoldIgnoredNotificationFromMessages(messages) {
+  if (assistantAwaitingToolsFromMessages(messages))
+    return true;
+  const latestAssistant = latestMessageByRole(messages, "assistant");
+  if (latestAssistant) {
+    const finish = latestAssistant.message.info.finish;
+    if (typeof finish !== "string" || finish.length === 0)
+      return true;
+    if (finish === "tool-calls" || finish === "unknown")
+      return true;
+  }
+  const latestRealUser = latestMessageByRole(messages, "user", true);
+  return latestRealUser !== null && latestRealUser.timeCreated > (latestAssistant?.timeCreated ?? -1);
+}
+function trackedMessages(session) {
+  return [...session.messages.values()].sort((left, right) => left.timeCreated - right.timeCreated).map((message) => ({
+    info: {
+      id: message.id,
+      role: message.role,
+      time: { created: message.timeCreated },
+      ...message.finish === undefined ? {} : { finish: message.finish }
+    },
+    parts: [...message.parts.values()]
+  }));
+}
+function logProbeFailureOnce(resolution, error) {
+  const failure = recordOpenCodeDbReadFailure(resolution, error);
+  if (!claimOpenCodeDbDiagnosticOnce("session-state-probe", resolution))
+    return;
+  const message = `[magic-context] OpenCode DB probe failed: path=${resolution.path} source=${resolution.source} cause=${failure.message}`;
+  probeLogObserverForTests?.(message);
+  log(message);
+}
+function resolvedDbIsAvailable() {
+  const resolution = resolveOpenCodeDbPath();
+  if (!harnessOwnsOpenCodeStore())
+    return { resolution, available: false };
+  const available = openCodeDbPathExists(resolution);
+  if (available)
+    clearOpenCodeDbReadFailure(resolution.path);
+  else
+    logProbeFailureOnce(resolution, "opencode_db_missing");
+  return { resolution, available };
+}
+function shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId) {
+  if (assistantAwaitingToolsFromOpenCodeDb(db, sessionId))
+    return true;
+  if (hasUnfinishedAssistant(db, sessionId))
+    return true;
+  if (hasUnansweredRealUser(db, sessionId))
+    return true;
+  return false;
+}
+function shouldHoldIgnoredNotification(sessionId) {
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "bypass")
+    return false;
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "hold")
+    return true;
+  const availability = resolvedDbIsAvailable();
+  const tracked = trackedSessions.get(sessionId);
+  if (tracked)
+    return shouldHoldIgnoredNotificationFromMessages(trackedMessages(tracked));
+  if (!availability.available)
+    return false;
+  try {
+    return withReadOnlySessionDb((db) => shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    logProbeFailureOnce(availability.resolution, error);
+    return false;
+  }
+}
+function assistantAwaitingToolsFromOpenCodeDb(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
+    return false;
+  if (latestAssistant.finish === "tool-calls")
+    return true;
+  const partRows = db.prepare("SELECT data FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001)").all(sessionId, latestAssistant.id);
+  return partRows.some((row) => {
+    if (typeof row.data !== "string" || row.data.length === 0)
+      return false;
+    try {
+      const part = JSON.parse(row.data);
+      return part.type === "tool" && part.providerExecuted !== true;
+    } catch {
+      return false;
+    }
+  });
+}
+function latestPersistedMessageForRecovery(sessionId) {
+  return withReadOnlySessionDb((db) => {
+    const row = db.prepare(`SELECT id, data
+                   FROM message
+                  WHERE session_id = ?
+                  ORDER BY time_created DESC, id DESC
+                  LIMIT 1`).get(sessionId);
+    if (typeof row?.id !== "string" || typeof row.data !== "string")
+      return null;
+    try {
+      const data = JSON.parse(row.data);
+      if (typeof data.role !== "string")
+        return null;
+      const time = data.time && typeof data.time === "object" ? data.time : null;
+      return {
+        id: row.id,
+        role: data.role,
+        ...typeof data.parentID === "string" ? { parentID: data.parentID } : {},
+        ...typeof time?.completed === "number" ? { completedAt: time.completed } : {},
+        ...data.error === undefined ? {} : { error: data.error }
+      };
+    } catch {
+      return null;
+    }
+  });
+}
+function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
+  if (typeof latestAssistantTimeCreated !== "number")
+    return false;
+  const row = db.prepare(`SELECT 1 as one
+             FROM message m
+             WHERE m.session_id = ?
+               AND m.time_created > ?
+               AND json_extract(m.data, '$.role') = 'user'
+               AND NOT (
+                 EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id)
+                 AND NOT EXISTS (
+                   SELECT 1 FROM part p
+                   WHERE p.message_id = m.id
+                     AND COALESCE(json_extract(p.data, '$.synthetic'), 0) NOT IN (1, 'true')
+                     AND json_extract(p.data, '$.metadata.marker.kind') IS NULL
+                     AND COALESCE(json_extract(p.data, '$.ignored'), 0) NOT IN (1, 'true')
+                 )
+               )
+             LIMIT 1`).get(sessionId, latestAssistantTimeCreated);
+  return row?.one === 1;
+}
+function latestAssistantRow(db, sessionId) {
+  return db.prepare(`SELECT id,
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
+             FROM message
+             WHERE session_id = ?
+               AND json_extract(data, '$.role') = 'assistant'
+             ORDER BY time_created DESC
+             LIMIT 1`).get(sessionId);
+}
+function hasUnfinishedAssistant(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  const finish = latestAssistant.finish;
+  if (typeof finish !== "string" || finish.length === 0)
+    return true;
+  return finish === "tool-calls" || finish === "unknown";
+}
+function hasUnansweredRealUser(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  const latestAssistantTime = typeof latestAssistant?.timeCreated === "number" ? latestAssistant.timeCreated : -1;
+  return hasNewerRealUserMessage(db, sessionId, latestAssistantTime);
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0 || !harnessOwnsOpenCodeStore())
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error) {
+    logProbeFailureOnce(resolveOpenCodeDbPath(), error);
+  }
+  return result;
+}
+function findLastAssistantModelFromOpenCodeDb(sessionId) {
+  if (!harnessOwnsOpenCodeStore())
+    return null;
+  const resolution = resolveOpenCodeDbPath();
+  try {
+    if (!openCodeDbPathExists(resolution)) {
+      throw new Error(`OpenCode session database is unavailable at ${resolution.path}`);
+    }
+    const db = new Database(resolution.path, { readonly: true });
+    try {
+      const queryV2 = () => db.prepare(`SELECT json_extract(data, '$.model.providerID') as providerID,
+                                json_extract(data, '$.model.id') as modelID,
+                                json_extract(data, '$.agent') as agent
+                         FROM session_message
+                         WHERE session_id = ?
+                           AND type = 'assistant'
+                           AND json_extract(data, '$.model.providerID') IS NOT NULL
+                           AND json_extract(data, '$.model.id') IS NOT NULL
+                         ORDER BY seq DESC
+                         LIMIT 1`).get(sessionId);
+      const queryV1 = () => db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
+                                json_extract(data, '$.modelID') as modelID,
+                                json_extract(data, '$.agent') as agent
+                         FROM message
+                         WHERE session_id = ?
+                           AND json_extract(data, '$.role') = 'assistant'
+                           AND json_extract(data, '$.providerID') IS NOT NULL
+                           AND json_extract(data, '$.modelID') IS NOT NULL
+                         ORDER BY time_created DESC
+                         LIMIT 1`).get(sessionId);
+      let row = null;
+      try {
+        assertOpenCodeStoreGeneration(db, "v2", resolution.path);
+        row = queryV2();
+      } catch {}
+      if (!row) {
+        try {
+          assertOpenCodeStoreGeneration(db, "v1", resolution.path);
+          row = queryV1();
+        } catch {}
+      }
+      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
+        return null;
+      }
+      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
+      return {
+        providerID: row.providerID,
+        modelID: row.modelID,
+        ...agent ? { agent } : {}
+      };
+    } finally {
+      closeQuietly(db);
+    }
+  } catch (error) {
+    logProbeFailureOnce(resolution, error);
+    return null;
+  }
+}
+
+export { openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, shouldHoldIgnoredNotification, latestPersistedMessageForRecovery, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };

package/dist/v2/server-x8a7jmkh.js

@@ -0,0 +1,104 @@
+// src/shared/rpc-notifications.ts
+var queue = [];
+var nextNotificationId = 1;
+var sinks = new Set;
+function registerNotificationSink2(sink) {
+  sinks.add(sink);
+  return () => {
+    sinks.delete(sink);
+  };
+}
+function notificationMatchesSink(notification, sink) {
+  if (notification.sessionId === undefined)
+    return true;
+  if (sink.sessionId !== undefined)
+    return notification.sessionId === sink.sessionId;
+  return sink.protocol !== 2;
+}
+function pushNotification2(type, payload, sessionId) {
+  const notification = { id: nextNotificationId++, type, payload, sessionId };
+  queue.push(notification);
+  for (const sink of sinks) {
+    if (!notificationMatchesSink(notification, sink))
+      continue;
+    try {
+      sink.send(notification);
+    } catch {}
+  }
+  if (queue.length > 100) {
+    const reservedIds = new Set;
+    const reservedScopes = new Set;
+    for (let i = queue.length - 1;i >= 0 && reservedScopes.size < 25; i -= 1) {
+      const candidate = queue[i];
+      const scope = candidate.sessionId ?? "\x00global";
+      if (reservedScopes.has(scope))
+        continue;
+      reservedScopes.add(scope);
+      reservedIds.add(candidate.id);
+    }
+    const evictionIndex = queue.findIndex((candidate) => !reservedIds.has(candidate.id));
+    queue.splice(evictionIndex >= 0 ? evictionIndex : 0, 1);
+  }
+}
+function acknowledgeNotifications2(ids) {
+  const acknowledged = new Set(ids.filter((id) => Number.isSafeInteger(id) && id > 0));
+  if (acknowledged.size === 0)
+    return;
+  queue = queue.filter((notification) => !acknowledged.has(notification.id));
+}
+function __resetNotificationStateForTests2() {
+  queue = [];
+  nextNotificationId = 1;
+  sinks.clear();
+}
+function cursor(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function drainNotifications2(lastReceivedId = 0, sessionId, options = {}) {
+  const sessionCursor = cursor(lastReceivedId);
+  if (options.globalOnly) {
+    queue = queue.filter((notification) => notification.sessionId !== undefined || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === undefined && notification.id > sessionCursor);
+  }
+  if (options.sessionOnly) {
+    if (sessionId === undefined)
+      return [];
+    queue = queue.filter((notification) => notification.sessionId !== sessionId || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === sessionId && notification.id > sessionCursor);
+  }
+  if (sessionId !== undefined && options.globalLastReceivedId !== undefined) {
+    const globalCursor = cursor(options.globalLastReceivedId);
+    queue = queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      if (notification.sessionId === sessionId)
+        return notification.id > sessionCursor;
+      return true;
+    });
+    return queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      return notification.sessionId === sessionId && notification.id > sessionCursor;
+    });
+  }
+  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
+  if (sessionCursor > 0) {
+    queue = queue.filter((notification) => !(notification.id <= sessionCursor && matchesClient(notification)));
+  }
+  return queue.filter((notification) => notification.id > sessionCursor && matchesClient(notification));
+}
+function isTuiConnected2(sessionId) {
+  if (sinks.size === 0)
+    return false;
+  if (sessionId === undefined)
+    return true;
+  for (const sink of sinks) {
+    if (sink.sessionId === sessionId)
+      return true;
+    if (sink.sessionId === undefined && sink.protocol !== 2)
+      return true;
+  }
+  return false;
+}
+
+export { registerNotificationSink2, pushNotification2, acknowledgeNotifications2, __resetNotificationStateForTests2, drainNotifications2, isTuiConnected2 };

package/dist/v2/server-y8v6yerm.js

@@ -0,0 +1,77 @@
+// src/shared/error-message.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function readString(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  return;
+}
+function clip(value, max) {
+  if (value.length <= max)
+    return value;
+  return `${value.slice(0, max)}…`;
+}
+function describeError(error) {
+  const stringForm = clip(safeString(error), 400);
+  if (!(error instanceof Error) && !(error && typeof error === "object")) {
+    return {
+      name: typeof error,
+      message: "",
+      stringForm,
+      brief: stringForm || "<empty>"
+    };
+  }
+  const obj = error;
+  const nameFromField = readString(obj.name);
+  const nameFromCtor = error?.constructor?.name;
+  const name = nameFromField ?? nameFromCtor ?? "Error";
+  const message = readString(obj.message) ?? "";
+  const status = readString(obj.status) ?? readString(obj.statusCode);
+  const code = readString(obj.code);
+  let causeName;
+  const cause = obj.cause;
+  if (cause && typeof cause === "object") {
+    const causeRecord = cause;
+    causeName = readString(causeRecord.name) ?? cause.constructor?.name;
+  }
+  const stack = readString(obj.stack);
+  const stackHead = stack ? stack.split(`
+`).slice(0, 4).map((l) => l.trim()).filter((l) => l.length > 0).join(" | ") : undefined;
+  const briefParts = [];
+  if (name)
+    briefParts.push(name);
+  if (message)
+    briefParts.push(`message="${clip(message, 200)}"`);
+  if (status)
+    briefParts.push(`status=${status}`);
+  if (code)
+    briefParts.push(`code=${code}`);
+  if (causeName)
+    briefParts.push(`cause=${causeName}`);
+  if (!message && stringForm && stringForm !== name) {
+    briefParts.push(`str="${clip(stringForm, 200)}"`);
+  }
+  const brief = briefParts.join(" ") || stringForm || name;
+  return {
+    name,
+    message,
+    ...status ? { status } : {},
+    ...code ? { code } : {},
+    ...causeName ? { causeName } : {},
+    ...stackHead ? { stackHead } : {},
+    stringForm,
+    brief
+  };
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "<unstringifiable>";
+  }
+}
+
+export { getErrorMessage, describeError };