@cortexkit/opencode-magic-context 0.49.34 → 0.49.35

package/dist/v2/server-468mya5v.js

@@ -0,0 +1,209 @@
+import {
+  sanitizeDiagnosticText
+} from "./server-z4p0ry94.js";
+
+// src/features/magic-context/fail-closed-block.ts
+var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
+function attachFailClosedBlockingProcessEvidence(process, evidence) {
+  Object.defineProperties(process, {
+    startTime: { configurable: true, value: evidence.startTime },
+    commandLine: { configurable: true, value: evidence.commandLine }
+  });
+  return process;
+}
+
+class FailClosedBlockingError extends Error {
+  code = "FAIL_CLOSED_BLOCKING";
+  reason;
+  constructor(message, reason, options) {
+    super(message, options);
+    this.name = "FailClosedBlockingError";
+    this.reason = reason;
+  }
+}
+var OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
+function isMagicContextHiddenAgentName(agent) {
+  if (agent === "smart-note-compiler" || agent.startsWith("smart-note-")) {
+    return true;
+  }
+  if (agent === "historian" || agent.startsWith("historian-"))
+    return true;
+  if (agent === "dreamer" || agent.startsWith("dreamer-"))
+    return true;
+  return false;
+}
+var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
+var MAX_FORMATTED_COMMAND_LINE_LENGTH = 80;
+function normalizeFailClosedProcessKind(process) {
+  switch (process.kind) {
+    case "OpenCode server":
+    case "OpenCode instance (TUI/CLI)":
+    case "Pi":
+    case "process":
+      return process.kind;
+  }
+  switch (process.harness?.trim().toLowerCase()) {
+    case "opencode server":
+      return "OpenCode server";
+    case "opencode instance (tui/cli)":
+    case "opencode instance":
+      return "OpenCode instance (TUI/CLI)";
+    case "pi":
+    case "pi harness":
+    case "omp":
+      return "Pi";
+    default:
+      return "process";
+  }
+}
+function formatFailClosedProcessStartTime(startTime) {
+  if (!Number.isFinite(startTime) || startTime <= 0)
+    return "unverified";
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      month: "short",
+      hour12: false
+    }).formatToParts(new Date(startTime));
+    const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+    if (!values.month || !values.day || !values.hour || !values.minute)
+      return "unverified";
+    return `${values.month} ${values.day} ${values.hour}:${values.minute}`;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedCommandLine(commandLine) {
+  if (typeof commandLine !== "string" || commandLine.trim().length === 0)
+    return "unverified";
+  try {
+    const normalized = commandLine.replaceAll("\x00", " ").replace(/\s+/g, " ").trim();
+    if (normalized.length === 0)
+      return "unverified";
+    const sanitized = sanitizeDiagnosticText(normalized).trim();
+    if (sanitized.length === 0)
+      return "unverified";
+    return sanitized.length > MAX_FORMATTED_COMMAND_LINE_LENGTH ? `${sanitized.slice(0, MAX_FORMATTED_COMMAND_LINE_LENGTH - 3)}...` : sanitized;
+  } catch {
+    return "unverified";
+  }
+}
+function formatFailClosedBlockingProcesses(processes) {
+  const uniqueProcesses = new Map;
+  for (const process of processes) {
+    if (!Number.isInteger(process.pid) || process.pid <= 0)
+      continue;
+    const candidate = {
+      kind: normalizeFailClosedProcessKind(process),
+      pid: process.pid,
+      startTime: process.startTime,
+      commandLine: process.commandLine
+    };
+    const previous = uniqueProcesses.get(process.pid);
+    if (!previous || previous.kind === "process" && candidate.kind !== "process") {
+      uniqueProcesses.set(process.pid, candidate);
+    } else {
+      uniqueProcesses.set(process.pid, {
+        ...previous,
+        startTime: previous.startTime ?? candidate.startTime,
+        commandLine: previous.commandLine ?? candidate.commandLine
+      });
+    }
+  }
+  const entries = [...uniqueProcesses.values()];
+  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
+  const rendered = visible.map(({ kind, pid }) => `${kind} (PID ${pid})`);
+  const omitted = entries.length - visible.length;
+  if (omitted > 0)
+    rendered.push(`${omitted} more blocking process(es)`);
+  if (rendered.length === 0)
+    return "a live process";
+  const summary = rendered.length === 1 ? rendered[0] : `${rendered.slice(0, -1).join(", ")}, and ${rendered.at(-1)}`;
+  const evidence = entries.map(({ kind, pid, startTime, commandLine }) => `- PID ${pid}: ${kind}, started ${formatFailClosedProcessStartTime(startTime)}, cmd: ${formatFailClosedCommandLine(commandLine)}`).join(`
+`);
+  return `${summary}
+Blocking process evidence:
+${evidence}`;
+}
+function formatFailClosedBlockingMessage(reason) {
+  if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      const arm = reason.unreadableArm ?? "io";
+      const recovery = arm === "io" ? `If none of these processes are running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop the relevant process before deleting it.`;
+      return [
+        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live process cannot be proven.`,
+        recovery,
+        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+      ].join(" ");
+    }
+    return [
+      `Magic Context cannot migrate the shared database (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      `The database is at upstream migration v${reason.persistedVersion}; this build needs v${reason.supportedVersion}.`,
+      "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
+      "If that host loads a pinned or cached older Magic Context build, a restart alone is not enough: stop it or update its Magic Context build, then start this host once so it migrates the database with nothing older attached.",
+      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+    ].join(" ");
+  }
+  if (reason.kind === "schema_fence") {
+    return [
+      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
+      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+    ].join(" ");
+  }
+  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
+  return [
+    `Magic Context cannot operate: persistent storage failed (${cause}).`,
+    "The plugin will not silently degrade to native compaction while enabled.",
+    `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+  ].join(" ");
+}
+function formatFailClosedBlockingSummary(reason) {
+  if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion}: RPC discovery file ${reason.unreadableFile} could not be read, so an older host may still be attached.`;
+    }
+    const blockers = reason.blockingProcesses.filter((process) => Number.isInteger(process.pid) && process.pid > 0).map((process) => `${normalizeFailClosedProcessKind(process)} (PID ${process.pid})`);
+    const named = blockers.length > 0 ? blockers.join(", ") : "a live process";
+    return `Magic Context cannot migrate the shared database from v${reason.persistedVersion} to v${reason.supportedVersion} while ${named} may still run an older Magic Context build. Stop or update that host, then start this one once.`;
+  }
+  if (reason.kind === "schema_fence") {
+    return `Magic Context cannot operate: the shared database is at v${reason.persistedVersion}, newer than this build supports (v${reason.supportedVersion}). Update and restart this host.`;
+  }
+  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
+  return `Magic Context cannot operate: persistent storage failed (${cause}).`;
+}
+function createFailClosedBlockingError(reason, options) {
+  return new FailClosedBlockingError(formatFailClosedBlockingMessage(reason), reason, options);
+}
+function isFailClosedBlockingError(error) {
+  return error instanceof FailClosedBlockingError || typeof error === "object" && error !== null && error.name === "FailClosedBlockingError" && error.code === "FAIL_CLOSED_BLOCKING";
+}
+function shouldBypassFailClosedBlock(input) {
+  if (input.isPiSubagentEnv === true)
+    return true;
+  if (input.isInternalChildSession === true)
+    return true;
+  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
+  if (agent.length === 0)
+    return false;
+  if (OPENCODE_INTERNAL_AGENT_NAMES.has(agent))
+    return true;
+  if (isMagicContextHiddenAgentName(agent))
+    return true;
+  return false;
+}
+function resolveAgentNameFromMessages(messages) {
+  for (let i = messages.length - 1;i >= 0; i -= 1) {
+    const info = messages[i]?.info;
+    if (!info || typeof info !== "object")
+      continue;
+    const agent = info.agent;
+    if (typeof agent === "string" && agent.length > 0)
+      return agent;
+  }
+  return;
+}
+
+export { FAIL_CLOSED_DOCTOR_COMMAND, attachFailClosedBlockingProcessEvidence, formatFailClosedBlockingMessage, formatFailClosedBlockingSummary, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, resolveAgentNameFromMessages };

package/dist/v2/server-55v5hpth.js

@@ -0,0 +1,270 @@
+import {
+  estimateTokens
+} from "./server-969cdpmg.js";
+import {
+  expandToolPart,
+  visitRawSessionMessages2,
+  readRawSessionMessageById2
+} from "./server-1xesqm5h.js";
+import {
+  getTagById2
+} from "./server-bpvsvtph.js";
+
+// src/tools/ctx-expand/render.ts
+import { createHash } from "node:crypto";
+function recoveryParts(sessionId, message, attachments) {
+  return attachments ? [...message.parts, ...attachments(sessionId, message.id)] : message.parts;
+}
+function attachmentNotice(part) {
+  const field = (value) => typeof value === "string" ? value.trim().replace(/[\r\n]+/g, " ") : "";
+  const source = isRecord(part.source) ? part.source : {};
+  const location = [part.url, part.path, source.uri, source.url, source.path].map(field).find((value) => value && !/^(data|blob):/i.test(value));
+  const name = field(part.filename) || field(part.name);
+  const mime = field(part.mime) || field(part.mimeType) || field(part.mediaType);
+  return `[file]${name ? ` ${name}` : ""}${mime ? ` (${mime})` : ""}` + `${location ? ` — stored location: ${location}` : ""}` + "; content not recovered. If needed, ask the user to attach it again.";
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function roleLabel(role) {
+  if (role === "assistant")
+    return "A (assistant)";
+  if (role === "user")
+    return "U (user)";
+  return role;
+}
+function verboseRoleLabel(msg) {
+  if (msg.role === "user" && msg.parts.length > 0 && msg.parts.every((part) => {
+    if (!isRecord(part))
+      return false;
+    if (part.type === "tool_result")
+      return true;
+    return part.type === "tool" && asToolPart(part)?.output != null;
+  }))
+    return "tool results";
+  return roleLabel(msg.role);
+}
+function truncate(value, max) {
+  const t = value.trim();
+  return t.length <= max ? t : `${t.slice(0, max)}…`;
+}
+function keyArg(input) {
+  if (!input)
+    return "";
+  for (const k of ["filePath", "path", "pattern", "query", "symbol", "module", "action"]) {
+    const v = input[k];
+    if (typeof v === "string" && v.length > 0)
+      return truncate(v, 60);
+  }
+  if (typeof input.description === "string")
+    return truncate(input.description, 60);
+  return "";
+}
+function asToolPart(part) {
+  const type = typeof part.type === "string" ? part.type : "";
+  if (type === "tool") {
+    const state = isRecord(part.state) ? part.state : null;
+    const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
+    const metadata = state && isRecord(state.metadata) ? state.metadata : null;
+    const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
+    return {
+      name: typeof part.tool === "string" ? part.tool : "tool",
+      callId: typeof part.callID === "string" ? part.callID : "",
+      title,
+      input: state && isRecord(state.input) ? state.input : null,
+      output
+    };
+  }
+  if (type === "tool_use") {
+    return {
+      name: typeof part.name === "string" ? part.name : "tool",
+      callId: typeof part.id === "string" ? part.id : "",
+      title: null,
+      input: isRecord(part.input) ? part.input : null,
+      output: null
+    };
+  }
+  if (type === "tool_result") {
+    const content = part.content;
+    const output = typeof content === "string" ? content : content != null ? JSON.stringify(content) : null;
+    return {
+      name: "tool_result",
+      callId: typeof part.tool_use_id === "string" ? part.tool_use_id : "",
+      title: null,
+      input: null,
+      output
+    };
+  }
+  return null;
+}
+function textOf(part) {
+  if (part.type === "text" && typeof part.text === "string")
+    return part.text;
+  return null;
+}
+function reasoningOf(part) {
+  if ((part.type === "reasoning" || part.type === "thinking") && typeof part.text === "string") {
+    return part.text;
+  }
+  return null;
+}
+function renderPartPreview(part, expandTools) {
+  if (!isRecord(part))
+    return null;
+  const expansion = expandToolPart(part, expandTools, true);
+  if (expansion !== null)
+    return `    • tool ${part.tool}: ${expansion}`;
+  const text = textOf(part);
+  if (text !== null) {
+    const t = truncate(text, 200);
+    return t.length > 0 ? `    • ${t}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const arg = keyArg(tool.input);
+    const head = arg ? `${tool.name}(${arg})` : tool.name;
+    return tool.output !== null ? `    • tool ${head} → output ~${estimateTokens(tool.output)} tok` : `    • tool ${head}`;
+  }
+  const reasoning = reasoningOf(part);
+  if (reasoning !== null)
+    return `    • [reasoning] ${truncate(reasoning, 120)}`;
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file" || type === "image")
+    return `    • ${attachmentNotice(part)}`;
+  if (type === "step-start" || type === "step-finish")
+    return null;
+  return `    • [${type}]`;
+}
+function renderPartFull(part) {
+  if (!isRecord(part))
+    return null;
+  const text = textOf(part);
+  if (text !== null) {
+    return text.trim().length > 0 ? `  [text]
+${text}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const lines = [];
+    const idSuffix = tool.callId ? ` #${tool.callId}` : "";
+    lines.push(`  [tool: ${tool.name}${idSuffix}]`);
+    if (tool.title && tool.title.trim().length > 0) {
+      lines.push(`  description: ${tool.title.trim()}`);
+    }
+    if (tool.input)
+      lines.push(`  input: ${JSON.stringify(tool.input)}`);
+    if (tool.output !== null)
+      lines.push(`  output:
+${tool.output}`);
+    return lines.join(`
+`);
+  }
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file" || type === "image")
+    return `  ${attachmentNotice(part)}`;
+  return null;
+}
+function renderMessageByOrdinal2(sessionId, ordinal, attachments) {
+  const found = [];
+  visitRawSessionMessages2(sessionId, ordinal, ordinal, (m) => {
+    if (m.ordinal === ordinal)
+      found.push(m);
+    return false;
+  });
+  const msg = found[0];
+  if (!msg) {
+    return `No message at ordinal ${ordinal} in this session's stored history — it was deleted ` + `(session prune/revert) or the ordinal is wrong, so it can't be recovered. ` + `Re-run the tool if you still need the data.`;
+  }
+  const rendered = recoveryParts(sessionId, msg, attachments).map(renderPartFull).filter((l) => l !== null);
+  const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
+  if (rendered.length === 0) {
+    lines.push("  (no recoverable content — message had only structural/reasoning parts)");
+  } else {
+    lines.push(...rendered);
+  }
+  return lines.join(`
+`);
+}
+function renderVerboseRange(sessionId, start, end, tokenBudget, expandTools, attachments) {
+  const out = [];
+  let usedTokens = 0;
+  let lastOrdinal = start - 1;
+  let truncated = false;
+  visitRawSessionMessages2(sessionId, start, end, (msg) => {
+    const header = `[${msg.ordinal}] ${verboseRoleLabel(msg)}`;
+    const partLines = recoveryParts(sessionId, msg, attachments).map((part) => renderPartPreview(part, expandTools)).filter((l) => l !== null);
+    const block = partLines.length > 0 ? `${header}
+${partLines.join(`
+`)}` : header;
+    const blockTokens = estimateTokens(block);
+    if (usedTokens + blockTokens > tokenBudget && out.length > 0) {
+      truncated = true;
+      return false;
+    }
+    out.push(block);
+    usedTokens += blockTokens;
+    lastOrdinal = msg.ordinal;
+    return true;
+  });
+  return { text: out.join(`
+
+`), lastOrdinal, truncated };
+}
+function renderVerboseRangeForTool2(sessionId, start, end, tokenBudget, expandTools, attachments) {
+  const v = renderVerboseRange(sessionId, start, end, tokenBudget, expandTools, attachments);
+  if (!v.text) {
+    return `No messages found in range ${start}-${end}. The range may be outside this session's history.`;
+  }
+  const out = [
+    `Messages ${start}-${v.lastOrdinal} (verbose). Recover any one in full with ctx_expand(message=<ordinal>):`,
+    "",
+    v.text
+  ];
+  if (v.truncated) {
+    out.push("", `Truncated at message ${v.lastOrdinal} (budget: ~${tokenBudget} tokens). Call again with start=${v.lastOrdinal + 1} end=${end} verbose=true for more.`);
+  }
+  return out.join(`
+`);
+}
+function renderItemByTag2(db, sessionId, number, textIndexDomain = "part", attachments) {
+  const tag = getTagById2(db, sessionId, number);
+  if (!tag)
+    return `no tag ${number} in this session; if ${number} came from a <session-history> heading or a ctx_search hit, it is an ordinal: use message=${number}`;
+  if (tag.type === "tool") {
+    const owner = tag.toolOwnerMessageId;
+    if (!owner)
+      return `Tag ${number}'s tool owner is unknown; its original call cannot be resolved safely.`;
+    const message = readRawSessionMessageById2(sessionId, owner);
+    if (!message)
+      return `Tag ${number}'s original tool owner is no longer in stored history.`;
+    const parts = message?.parts.filter((part) => isRecord(part) && asToolPart(part)?.callId === tag.messageId) ?? [];
+    if (!parts.some((part) => isRecord(part) && asToolPart(part)?.output !== null)) {
+      visitRawSessionMessages2(sessionId, message.ordinal + 1, Number.MAX_SAFE_INTEGER, (candidate) => {
+        const matching = candidate.parts.filter((part) => isRecord(part) && asToolPart(part)?.callId === tag.messageId);
+        if (matching.some((part) => isRecord(part) && part.type === "tool_use"))
+          return false;
+        parts.push(...matching);
+        return matching.length === 0;
+      });
+    }
+    const rendered = parts.map(renderPartFull).filter((part) => part !== null);
+    return rendered.length ? rendered.join(`
+`) : `Tag ${number}'s original tool call is no longer in stored history.`;
+  }
+  const scoped = /^(.*):(?:p|file)(\d+)$/.exec(tag.messageId);
+  const derived = /^(.*):mc-text-v1:([a-f0-9]+):([a-f0-9]+):o(\d+)$/.exec(tag.messageId);
+  const owner = scoped?.[1] ?? derived?.[1] ?? tag.messageId;
+  const message = readRawSessionMessageById2(sessionId, owner);
+  if (!message)
+    return `Tag ${number}'s original text is no longer in stored history.`;
+  const index = scoped ? Number(scoped[2]) : 0;
+  const attached = attachments?.(sessionId, message.id) ?? [];
+  const parts = [...message.parts, ...attached];
+  const piText = parts.filter((part) => isRecord(part) && part.type === "text");
+  const part = tag.type === "file" ? attached.find((part) => isRecord(part) && part.partIndex === index) ?? message.parts[index] : parts[index];
+  const matching = derived ? piText.filter((part) => isRecord(part) && typeof part.text === "string" && createHash("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" && tag.type !== "file" ? piText[index] : part;
+  return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
+}
+
+export { renderMessageByOrdinal2, renderVerboseRangeForTool2, renderItemByTag2 };