@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/dist/v2/server-z19x7eqz.js

@@ -0,0 +1,423 @@
+import {
+  importPluginModule,
+  sessionLog
+} from "./server-ckpc8pxy.js";
+import {
+  isDefaultSessionTitle2
+} from "./server-5317ykaf.js";
+import {
+  shouldHoldIgnoredNotification
+} from "./server-w99cyt6a.js";
+import {
+  getErrorMessage
+} from "./server-y8v6yerm.js";
+
+// src/shared/embedding-activity.ts
+var busySessions = new Set;
+function setEmbeddingSessionBusy(sessionId, busy) {
+  if (busy)
+    busySessions.add(sessionId);
+  else
+    busySessions.delete(sessionId);
+}
+function observeEmbeddingActivity(event) {
+  const props = event.properties;
+  if (!props || typeof props.sessionID !== "string")
+    return;
+  if (event.type === "session.idle" || event.type === "session.deleted" || event.type === "session.status" && props.status?.type === "idle") {
+    setEmbeddingSessionBusy(props.sessionID, false);
+  } else if (event.type === "session.status" && props.status?.type) {
+    setEmbeddingSessionBusy(props.sessionID, true);
+  }
+}
+function isEmbeddingHostBusy() {
+  return busySessions.size > 0;
+}
+
+// src/hooks/magic-context/send-session-notification.ts
+var MAX_QUEUED_IGNORED_NOTIFICATIONS2 = 16;
+var queuedIgnoredNotifications = new Map;
+var flushingIgnoredNotifications = new Set;
+var idleSessions = new Set;
+var lastDeliveredText = new Map;
+var activityEpoch = new Map;
+var defaultHoldDetector = (sessionId) => !idleSessions.has(sessionId) || shouldHoldIgnoredNotification(sessionId);
+var holdDetector = defaultHoldDetector;
+var notificationServerUrl;
+var noticeDeleter;
+var notificationDiagnosticObserverForTests;
+function notificationDiagnostic(sessionId, message) {
+  notificationDiagnosticObserverForTests?.(message);
+  sessionLog(sessionId, message);
+}
+function queueIgnoredNotification(notification) {
+  const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
+  if (queued.at(-1)?.text === notification.text)
+    return;
+  queued.push(notification);
+  if (queued.length > MAX_QUEUED_IGNORED_NOTIFICATIONS2) {
+    queued.splice(0, queued.length - MAX_QUEUED_IGNORED_NOTIFICATIONS2);
+    sessionLog(notification.sessionId, `ignored notification queue full; dropped oldest entries (kept newest ${MAX_QUEUED_IGNORED_NOTIFICATIONS2})`);
+  }
+  queuedIgnoredNotifications.set(notification.sessionId, queued);
+}
+function holdIgnoredNotification(notification, checkpoint) {
+  queueIgnoredNotification(notification);
+  notificationDiagnostic(notification.sessionId, `ignored notification held ${checkpoint} (session active); queued`);
+}
+async function trySendTuiToast(sessionId, text, params, forcePersist) {
+  if (forcePersist)
+    return false;
+  const title = extractToastTitle(text);
+  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+  const toastVariant = inferToastVariant(text);
+  const duration = params.toastDurationMs ?? 5000;
+  const { isTuiConnected: checkTui } = await importPluginModule(() => import("./rpc-notifications-3hed126v.js"));
+  if (!checkTui(sessionId))
+    return false;
+  try {
+    const { pushNotification } = await importPluginModule(() => import("./rpc-notifications-3hed126v.js"));
+    pushNotification("toast", {
+      title,
+      message,
+      variant: toastVariant,
+      duration
+    }, sessionId);
+    return true;
+  } catch {
+    sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
+    return false;
+  }
+}
+var __ignoredNotificationTest2 = {
+  pendingTexts(sessionId) {
+    return (queuedIgnoredNotifications.get(sessionId) ?? []).map((item) => item.text);
+  },
+  reset() {
+    queuedIgnoredNotifications.clear();
+    flushingIgnoredNotifications.clear();
+    idleSessions.clear();
+    lastDeliveredText.clear();
+    activityEpoch.clear();
+    holdDetector = defaultHoldDetector;
+    notificationServerUrl = undefined;
+    noticeDeleter = undefined;
+    notificationDiagnosticObserverForTests = undefined;
+  },
+  setHoldDetector(detector) {
+    holdDetector = detector;
+  },
+  setNoticeDeleter(deleter) {
+    noticeDeleter = deleter;
+  },
+  setDiagnosticObserver(observer) {
+    notificationDiagnosticObserverForTests = observer;
+  }
+};
+function setNotificationServerUrl2(url) {
+  notificationServerUrl = typeof url === "string" && url.length > 0 ? url.replace(/\/$/, "") : undefined;
+}
+function notifyDelivered(sessionId, params) {
+  try {
+    params.onDelivered?.();
+  } catch (error) {
+    sessionLog(sessionId, "notification delivery callback failed:", getErrorMessage(error));
+  }
+}
+function hasNotificationSessionClient(client) {
+  if (client === null || typeof client !== "object")
+    return false;
+  const candidate = client;
+  if (candidate.session === undefined)
+    return true;
+  if (candidate.session === null || typeof candidate.session !== "object")
+    return false;
+  const session = candidate.session;
+  return (session.prompt === undefined || typeof session.prompt === "function") && (session.promptAsync === undefined || typeof session.promptAsync === "function");
+}
+function inferToastVariant(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("error") || lower.includes("failed") || lower.includes("alert"))
+    return "error";
+  if (lower.includes("warning") || lower.includes("⚠"))
+    return "warning";
+  if (lower.includes("complete") || lower.includes("success") || lower.includes("✓") || lower.includes("finished"))
+    return "success";
+  return "info";
+}
+function extractToastTitle(text) {
+  const headingMatch = text.match(/^#+\s+(.+)/m);
+  if (headingMatch)
+    return headingMatch[1].trim();
+  const firstLine = text.split(`
+`)[0].trim();
+  if (firstLine.length <= 80)
+    return firstLine;
+  return "Magic Context";
+}
+async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
+  const epoch = activityEpoch.get(sessionId) ?? 0;
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
+    return "queued";
+  }
+  const { waitForSafeNotificationTarget } = await importPluginModule(() => import("./safe-notification-target-wtj0bbc2.js"));
+  if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
+    sessionLog(sessionId, "notification skipped (session not titled yet)");
+    return "skipped";
+  }
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
+    return "queued";
+  }
+  if (!hasNotificationSessionClient(client)) {
+    sessionLog(sessionId, "session prompt API unavailable for notification");
+    return "failed";
+  }
+  const c = client;
+  let agent = params.agent || undefined;
+  let variant = params.variant || undefined;
+  let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
+  if (!agent || !model || !variant) {
+    try {
+      const { resolvePromptContext } = await importPluginModule(() => import("./prompt-context-5y5ms8f9.js"));
+      const resolved = await resolvePromptContext(client, sessionId);
+      if (resolved) {
+        agent = agent ?? resolved.agent;
+        model = model ?? resolved.model;
+        variant = variant ?? resolved.variant;
+      }
+    } catch {}
+  }
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before append");
+    return "queued";
+  }
+  const input = {
+    path: { id: sessionId },
+    body: {
+      noReply: true,
+      agent,
+      model,
+      variant,
+      parts: [
+        {
+          type: "text",
+          text,
+          ignored: true
+        }
+      ]
+    }
+  };
+  try {
+    let result;
+    if (typeof c.session?.prompt === "function") {
+      result = await Promise.resolve(c.session.prompt(input));
+    } else if (typeof c.session?.promptAsync === "function") {
+      result = await c.session.promptAsync(input);
+    } else {
+      sessionLog(sessionId, "session prompt API unavailable for notification");
+      return "failed";
+    }
+    const messageId = extractPromptedMessageId(result);
+    if (await revertNoticeIfUnsafe({
+      client,
+      sessionId,
+      text,
+      params,
+      forcePersist,
+      messageId,
+      epoch
+    })) {
+      return "skipped";
+    }
+    lastDeliveredText.set(sessionId, text);
+    notifyDelivered(sessionId, params);
+    return "sent";
+  } catch (error) {
+    const msg = getErrorMessage(error);
+    sessionLog(sessionId, "failed to send notification:", msg);
+    return "failed";
+  }
+}
+function extractPromptedMessageId(result) {
+  if (result === null || typeof result !== "object")
+    return;
+  const root = result;
+  const data = root.data !== null && typeof root.data === "object" ? root.data : root;
+  const info = data.info !== null && typeof data.info === "object" ? data.info : data;
+  return typeof info.id === "string" && info.id.length > 0 ? info.id : undefined;
+}
+function getServerAuth() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password)
+    return;
+  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function deleteNoticeMessage(sessionId, messageId) {
+  if (noticeDeleter)
+    return noticeDeleter(sessionId, messageId);
+  if (!notificationServerUrl) {
+    sessionLog(sessionId, "cannot roll back notice: no server URL for session.message.delete");
+    return false;
+  }
+  const url = `${notificationServerUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
+  try {
+    const auth = getServerAuth();
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: auth ? { Authorization: auth } : {},
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      sessionLog(sessionId, `notice rollback DELETE failed status=${response.status} url=${url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    sessionLog(sessionId, "notice rollback DELETE error:", getErrorMessage(error));
+    return false;
+  }
+}
+async function revertNoticeIfUnsafe(notification) {
+  const superseded = (activityEpoch.get(notification.sessionId) ?? 0) !== notification.epoch;
+  if (!superseded && !holdDetector(notification.sessionId))
+    return false;
+  if (notification.messageId) {
+    const deleted = await deleteNoticeMessage(notification.sessionId, notification.messageId);
+    if (deleted) {
+      notificationDiagnostic(notification.sessionId, `notice rolled back (deleted row ${notification.messageId}); consumed after append`);
+    } else {
+      sessionLog(notification.sessionId, "failed to roll back a notice that landed while a run was active");
+    }
+  } else {
+    sessionLog(notification.sessionId, "notice landed while a run was active but the new row id was not returned");
+  }
+  lastDeliveredText.set(notification.sessionId, notification.text);
+  return true;
+}
+async function sendCommandResult2(client, sessionId, text, params) {
+  if (shouldHoldIgnoredNotification(sessionId)) {
+    return sendIgnoredMessage2(client, sessionId, text, params);
+  }
+  const { isTuiConnected } = await importPluginModule(() => import("./rpc-notifications-3hed126v.js"));
+  if (isTuiConnected(sessionId))
+    return sendIgnoredMessage2(client, sessionId, text, params);
+  const session = client?.session;
+  try {
+    const title = (await session?.get?.({ path: { id: sessionId } }))?.data?.title;
+    if (title && isDefaultSessionTitle2(title)) {
+      if (!session?.update)
+        return "failed";
+      const updated = await session.update({
+        path: { id: sessionId },
+        body: { title: "Magic Context" }
+      });
+      if (updated.error)
+        return "failed";
+    }
+    idleSessions.add(sessionId);
+    const disposition = await sendIgnoredMessage2(client, sessionId, text, params);
+    if (disposition === "sent" && !shouldHoldIgnoredNotification(sessionId)) {
+      await session?.abort?.({ path: { id: sessionId } });
+    }
+    return disposition;
+  } catch (error) {
+    sessionLog(sessionId, "command result delivery failed:", getErrorMessage(error));
+    return "failed";
+  }
+}
+async function sendIgnoredMessage2(client, sessionId, text, params, forcePersist = false) {
+  if (await trySendTuiToast(sessionId, text, params, forcePersist)) {
+    notifyDelivered(sessionId, params);
+    return "sent";
+  }
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before target checks");
+    return "queued";
+  }
+  if (lastDeliveredText.get(sessionId) === text)
+    return "sent";
+  return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
+}
+async function flushIgnoredMessages2(sessionId) {
+  if (flushingIgnoredNotifications.has(sessionId))
+    return;
+  const queued = queuedIgnoredNotifications.get(sessionId);
+  if (!queued || queued.length === 0)
+    return;
+  if (holdDetector(sessionId))
+    return;
+  const epoch = activityEpoch.get(sessionId) ?? 0;
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.add(sessionId);
+  try {
+    for (const notification of queued) {
+      if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+        break;
+      const disposition = await sendIgnoredMessage2(notification.client, notification.sessionId, notification.text, notification.params, notification.forcePersist);
+      if (disposition === "queued") {
+        for (const remaining of queued.slice(queued.indexOf(notification) + 1)) {
+          queueIgnoredNotification(remaining);
+        }
+        break;
+      }
+    }
+  } finally {
+    flushingIgnoredNotifications.delete(sessionId);
+  }
+}
+function clearIgnoredMessages2(sessionId) {
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.delete(sessionId);
+  idleSessions.delete(sessionId);
+  lastDeliveredText.delete(sessionId);
+  activityEpoch.delete(sessionId);
+}
+function observeIgnoredNotificationEvent2(event) {
+  observeEmbeddingActivity(event);
+  const record = (value) => value !== null && typeof value === "object" ? value : undefined;
+  const props = record(event.properties);
+  const info = record(props?.info);
+  const part = record(props?.part);
+  const sessionId = props?.sessionID ?? info?.sessionID ?? part?.sessionID;
+  if (typeof sessionId !== "string")
+    return;
+  if (event.type === "session.idle") {
+    idleSessions.add(sessionId);
+    return;
+  }
+  if (event.type === "session.deleted") {
+    clearIgnoredMessages2(sessionId);
+    return;
+  }
+  const active = event.type === "session.status" && record(props?.status)?.type !== "idle" || event.type === "message.updated" && info?.role === "assistant" || event.type === "message.part.updated" && part?.ignored !== true && part?.type !== "compaction";
+  if (!active)
+    return;
+  idleSessions.delete(sessionId);
+  activityEpoch.set(sessionId, (activityEpoch.get(sessionId) ?? 0) + 1);
+  queuedIgnoredNotifications.delete(sessionId);
+}
+async function sendStatusNotification2(_client, sessionId, text, params) {
+  try {
+    const { pushNotification } = await importPluginModule(() => import("./rpc-notifications-3hed126v.js"));
+    pushNotification("toast", {
+      title: extractToastTitle(text),
+      message: text,
+      variant: inferToastVariant(text),
+      duration: params.toastDurationMs ?? 5000
+    }, sessionId);
+    notifyDelivered(sessionId, params);
+    return "sent";
+  } catch (error) {
+    sessionLog(sessionId, "status RPC enqueue failed:", getErrorMessage(error));
+    return "failed";
+  }
+}
+
+export { isEmbeddingHostBusy, MAX_QUEUED_IGNORED_NOTIFICATIONS2, __ignoredNotificationTest2, setNotificationServerUrl2, sendCommandResult2, sendIgnoredMessage2, flushIgnoredMessages2, clearIgnoredMessages2, observeIgnoredNotificationEvent2, sendStatusNotification2 };

package/dist/v2/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/v2/server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,SAAS,CAQ7E;AAED,wBAAsB,KAAK,CAAC,OAAO,EAAE,SAAS,gCAsB7C;;;;;AAED,wBAGE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/v2/server.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,SAAS,CAQ7E;AAED,wBAAsB,KAAK,CAAC,OAAO,EAAE,SAAS,gCA2B7C;;;;;AAED,wBAGE"}