@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/index-me3zcj5t.js

@@ -0,0 +1,69 @@
+// src/shared/model-resolution.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function readString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveHarnessBlock(container, harness) {
+  return asRecord(container?.[harness]);
+}
+function normalizeModelEntry(entry, harness) {
+  if (typeof entry === "string") {
+    const model = readString(entry);
+    return model ? { model } : undefined;
+  }
+  const objectEntry = asRecord(entry);
+  if (!objectEntry)
+    return;
+  const model = readString(objectEntry.model);
+  if (!model)
+    return;
+  const qualifier = readString(objectEntry[harness === "opencode" ? "variant" : "thinking_level"]);
+  return qualifier ? { model, qualifier } : { model };
+}
+function isValidModelReference(entry) {
+  const slash = entry.model.indexOf("/");
+  return slash > 0 && slash < entry.model.length - 1;
+}
+function sameAttempt(a, b) {
+  return a.model === b.model && a.qualifier === b.qualifier;
+}
+function resolveFallbackEntries(value, harness) {
+  const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+  const resolved = [];
+  for (const value of values) {
+    const entry = normalizeModelEntry(value, harness);
+    if (!entry || !isValidModelReference(entry))
+      continue;
+    if (resolved.some((candidate) => sameAttempt(candidate, entry)))
+      continue;
+    resolved.push(entry);
+  }
+  return resolved;
+}
+function resolvePrimaryEntry(args) {
+  const entry = normalizeModelEntry(args.entry, args.harness);
+  if (!entry)
+    return;
+  const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
+  return qualifier ? { ...entry, qualifier } : entry;
+}
+function resolveHistorianModel2(config, harness) {
+  const historian = asRecord(asRecord(config)?.historian);
+  const block = resolveHarnessBlock(historian, harness);
+  if (!block)
+    return { fallbacks: [] };
+  return {
+    primary: resolvePrimaryEntry({
+      entry: block.model,
+      defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+      harness
+    }),
+    fallbacks: resolveFallbackEntries(block.fallback_models, harness)
+  };
+}
+export { resolveHistorianModel2 };

package/dist/index-qbkzdkk0.js

@@ -0,0 +1,496 @@
+// src/shared/data-path.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// src/shared/harness.ts
+var currentHarness = "opencode";
+var harnessLocked = false;
+function setHarness(value) {
+  if (harnessLocked && currentHarness !== value) {
+    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
+  }
+  currentHarness = value;
+  harnessLocked = true;
+}
+function getHarness() {
+  return currentHarness;
+}
+function harnessOwnsOpenCodeStore(harness = currentHarness) {
+  return harness === "opencode" || harness === "opencode2";
+}
+
+// src/shared/test-temp-dir.ts
+var STALE_TEMP_DIR_AGE_MS = 60 * 60 * 1000;
+var registeredTempDirs = new Set;
+
+// src/shared/data-path.ts
+function getDataDir() {
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+function getMagicContextTempDir(harness = getHarness()) {
+  return path.join(os.tmpdir(), harness, "magic-context");
+}
+function getMagicContextLogPath(harness = getHarness()) {
+  const envPath = process.env.MMC_LOG_PATH?.trim();
+  if (envPath)
+    return envPath;
+  return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+function getProjectMagicContextDir(directory) {
+  return path.join(directory, ".mmc", "magic-context");
+}
+var GITIGNORE_GUARD_OPEN = "# >>> mmc:magic-context";
+var GITIGNORE_GUARD_CLOSE = "# <<< mmc:magic-context";
+function ensureMmcArtifactGitignore(directory) {
+  try {
+    const mmcDir = path.join(directory, ".mmc");
+    const gitignorePath = path.join(mmcDir, ".gitignore");
+    let existing = "";
+    if (existsSync(gitignorePath)) {
+      existing = readFileSync(gitignorePath, "utf8");
+      if (existing.includes(GITIGNORE_GUARD_OPEN))
+        return;
+    }
+    const block = `${GITIGNORE_GUARD_OPEN}
+magic-context/
+${GITIGNORE_GUARD_CLOSE}
+`;
+    const needsLeadingNewline = existing.length > 0 && !existing.endsWith(`
+`);
+    const next = existing + (needsLeadingNewline ? `
+` : "") + block;
+    mkdirSync(mmcDir, { recursive: true });
+    writeFileSync(gitignorePath, next, "utf8");
+  } catch {}
+}
+function getProjectMagicContextHistorianDir(directory) {
+  return path.join(getProjectMagicContextDir(directory), "historian");
+}
+function getOpenCodeStorageDir() {
+  return path.join(getDataDir(), "opencode", "storage");
+}
+function getMagicContextStorageResolution() {
+  const testDataDir = process.env.MMC_TEST_DATA_DIR?.trim();
+  if (testDataDir) {
+    const perTestDataHome = process.env.XDG_DATA_HOME?.trim();
+    if (perTestDataHome && path.resolve(perTestDataHome) !== path.resolve(testDataDir)) {
+      return {
+        path: path.join(perTestDataHome, "mmc"),
+        source: "test isolation"
+      };
+    }
+    return {
+      path: path.join(testDataDir, "mmc"),
+      source: "test isolation"
+    };
+  }
+  if (false) {}
+  const explicitStorageDir = process.env.MMC_STORAGE_DIR?.trim();
+  if (explicitStorageDir) {
+    if (!path.isAbsolute(explicitStorageDir)) {
+      throw new Error("MMC_STORAGE_DIR must be an absolute path");
+    }
+    return { path: explicitStorageDir, source: "environment override" };
+  }
+  const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+  if (xdgDataHome) {
+    return {
+      path: path.join(xdgDataHome, "mmc"),
+      source: "XDG_DATA_HOME"
+    };
+  }
+  return {
+    path: path.join(os.homedir(), ".local", "share", "mmc"),
+    source: "platform default"
+  };
+}
+function getMagicContextStorageDir() {
+  return getMagicContextStorageResolution().path;
+}
+function getLegacyOpenCodeMagicContextStorageDir() {
+  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+}
+
+// src/shared/logger.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+
+// src/shared/redaction.ts
+import { homedir as homedir2, userInfo } from "node:os";
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var SECRET_WORDS = [
+  "key",
+  "token",
+  "secret",
+  "password",
+  "auth",
+  "authorization",
+  "bearer",
+  "credential"
+];
+var SECRET_SEGMENT_PATTERN = new RegExp(`^(?:${SECRET_WORDS.map((w) => `${w}s?`).join("|")})$`, "i");
+var TRAILING_DESCRIPTORS = new Set(["id", "ids", "value", "values", "header", "headers"]);
+function redactionTypeForKey(key) {
+  const normalized = key.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "_");
+  const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
+  return suffix || "secret";
+}
+function isNonSecretScalarValue(value) {
+  const v = value.trim();
+  if (v === "true" || v === "false" || v === "null" || v === "undefined")
+    return true;
+  return /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(v);
+}
+var SECRET_QUALIFIERS = new Set([
+  "api",
+  "access",
+  "private",
+  "client",
+  "auth",
+  "authorization",
+  "secret",
+  "bearer",
+  "session",
+  "refresh",
+  "service",
+  "x",
+  "openai",
+  "anthropic",
+  "google",
+  "github",
+  "huggingface",
+  "aws",
+  "azure",
+  "id"
+]);
+var UNQUALIFIED_SECRET_SEGMENT_PATTERN = /^(?:password|secret|credential|bearer|authorization)s?$/;
+function isSecretKey(key) {
+  const segments = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[._-]+/).filter(Boolean);
+  if (segments.length === 0)
+    return false;
+  if (segments.length === 1) {
+    const first = segments[0];
+    return Boolean(first && SECRET_SEGMENT_PATTERN.test(first));
+  }
+  for (let i = 0;i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg || !SECRET_SEGMENT_PATTERN.test(seg))
+      continue;
+    let trailingOk = true;
+    for (let j = i + 1;j < segments.length; j++) {
+      const tail = segments[j];
+      if (!tail)
+        continue;
+      if (TRAILING_DESCRIPTORS.has(tail))
+        continue;
+      if (SECRET_SEGMENT_PATTERN.test(tail))
+        continue;
+      trailingOk = false;
+      break;
+    }
+    if (!trailingOk)
+      continue;
+    if (UNQUALIFIED_SECRET_SEGMENT_PATTERN.test(seg))
+      return true;
+    for (let k = i - 1;k >= 0; k--) {
+      const lead = segments[k];
+      if (lead && SECRET_QUALIFIERS.has(lead))
+        return true;
+    }
+  }
+  return false;
+}
+function sanitizePathString(value) {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir2();
+  const username = userInfo().username;
+  let sanitized = value;
+  if (home) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex(home), "g"), "~");
+  }
+  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
+  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
+  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
+  if (username) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
+  }
+  return sanitized;
+}
+var SECRET_TEXT_PATTERNS = [
+  {
+    pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
+    replacement: "<ANTHROPIC_API_KEY_REDACTED>"
+  },
+  {
+    pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{12,}/g,
+    replacement: "<OPENAI_API_KEY_REDACTED>"
+  },
+  {
+    pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    replacement: "<GITHUB_PAT_REDACTED>"
+  },
+  {
+    pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
+    replacement: "<GITHUB_TOKEN_REDACTED>"
+  },
+  {
+    pattern: /\bhf_[A-Za-z0-9]{30,}/g,
+    replacement: "<HUGGINGFACE_TOKEN_REDACTED>"
+  },
+  {
+    pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+    replacement: "<AWS_ACCESS_KEY_ID_REDACTED>"
+  },
+  {
+    pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
+    replacement: "<SLACK_TOKEN_REDACTED>"
+  },
+  {
+    pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+    replacement: "<GOOGLE_API_KEY_REDACTED>"
+  },
+  {
+    pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
+    replacement: (_full, prefix) => `${prefix}<REDACTED:bearer>`
+  },
+  {
+    pattern: /\b((?:Proxy-)?Authorization\s*:\s*(?:Basic|Digest|Token|Negotiate|NTLM)\s+)([A-Za-z0-9._~+/=-]{4,})/gi,
+    replacement: (_full, prefix) => `${prefix}<REDACTED:authorization>`
+  },
+  {
+    pattern: /\b((?:x-)?(?:api-?key|api-?token|auth-?token|access-?token)\s*:\s*)([^\s'"`,;<>]{6,})/gi,
+    replacement: (full, prefix, value) => isNonSecretScalarValue(value) ? full : `${prefix}<REDACTED:api_key>`
+  },
+  {
+    pattern: /\b([a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:)([^\s/@]+)(@)/gi,
+    replacement: (_full, prefix, _password, at) => `${prefix}<REDACTED:password>${at}`
+  },
+  {
+    pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+    replacement: "<JWT_REDACTED>"
+  },
+  {
+    pattern: /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
+    replacement: (full, quote, key, separator, valueQuote, value) => isNonSecretScalarValue(value) ? full : `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`
+  },
+  {
+    pattern: /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
+    replacement: (full, key, value) => isNonSecretScalarValue(value) ? full : `${key}=<REDACTED:${redactionTypeForKey(key)}>`
+  }
+];
+function redactSecretText(value) {
+  let redacted = value;
+  for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
+    if (typeof replacement === "string") {
+      redacted = redacted.replace(pattern, replacement);
+    } else {
+      redacted = redacted.replace(pattern, replacement);
+    }
+  }
+  return redacted;
+}
+function sanitizeDiagnosticText(value) {
+  return redactSecretText(sanitizePathString(value));
+}
+function sanitizeConfigValue(value, keyPath = []) {
+  if (value === null || typeof value === "number" || typeof value === "boolean")
+    return value;
+  const key = keyPath.at(-1) ?? "";
+  if (key && isSecretKey(key)) {
+    return `<REDACTED:${redactionTypeForKey(key)}>`;
+  }
+  if (typeof value === "string")
+    return sanitizeDiagnosticText(value);
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeConfigValue(entry, [...keyPath, String(index)]));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [
+      entryKey,
+      sanitizeConfigValue(entry, [...keyPath, entryKey])
+    ]));
+  }
+  return value;
+}
+
+// src/shared/logger.ts
+var isTestEnv = false;
+var buffer = [];
+var flushTimer = null;
+var FLUSH_INTERVAL_MS = 500;
+var BUFFER_SIZE_LIMIT = 50;
+var MAX_BUFFERED_BYTES = 1024 * 1024;
+var bufferedBytes = 0;
+var droppedLines = 0;
+function boundBuffer() {
+  while (bufferedBytes > MAX_BUFFERED_BYTES && buffer.length > 0) {
+    bufferedBytes -= Buffer.byteLength(buffer.shift() ?? "");
+    droppedLines++;
+  }
+}
+var MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+var SIZE_CHECK_INTERVAL_FLUSHES = 64;
+var activeLogFile = null;
+var activeLogSize = null;
+var flushesSinceSizeCheck = 0;
+var swallowedWriteCount = 0;
+var lastErrorMessage = null;
+var lastErrorTime = null;
+function recordSwallowedWrite(error) {
+  try {
+    swallowedWriteCount++;
+    lastErrorMessage = sanitizeDiagnosticText(error instanceof Error ? error.message : String(error));
+    lastErrorTime = new Date().toISOString();
+  } catch {}
+}
+function ensureDir(filePath) {
+  fs.mkdirSync(path2.dirname(filePath), { recursive: true });
+}
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function getCurrentLogSize(logFile) {
+  if (activeLogFile === logFile && activeLogSize !== null && flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES) {
+    return activeLogSize;
+  }
+  try {
+    const stat = fs.statSync(logFile);
+    if (!stat.isFile()) {
+      throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+    }
+    fs.chmodSync(logFile, 384);
+    activeLogFile = logFile;
+    activeLogSize = stat.size;
+    flushesSinceSizeCheck = 0;
+    return stat.size;
+  } catch (error) {
+    if (!isMissingFile(error))
+      throw error;
+    activeLogFile = logFile;
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+    return 0;
+  }
+}
+function capLogData(data) {
+  if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES)
+    return data;
+  let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+  while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+    bounded = bounded.slice(0, -1);
+  }
+  return bounded;
+}
+function writeBoundedPredecessor(logFile, predecessorPath, size) {
+  const predecessorFd = fs.openSync(predecessorPath, "w", 384);
+  try {
+    fs.fchmodSync(predecessorFd, 384);
+    const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+    const sourceFd = fs.openSync(logFile, "r");
+    try {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+      let remaining = bytesToCopy;
+      let position = Math.max(0, size - bytesToCopy);
+      while (remaining > 0) {
+        const bytesRead = fs.readSync(sourceFd, chunk, 0, Math.min(chunk.length, remaining), position);
+        if (bytesRead === 0)
+          break;
+        fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+    } finally {
+      fs.closeSync(sourceFd);
+    }
+  } finally {
+    fs.closeSync(predecessorFd);
+  }
+}
+function rotateLogFile(logFile, size) {
+  const predecessorPath = `${logFile}.1`;
+  writeBoundedPredecessor(logFile, predecessorPath, size);
+  fs.truncateSync(logFile, 0);
+  activeLogSize = 0;
+  flushesSinceSizeCheck = 0;
+}
+function flush() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  if (buffer.length === 0 && droppedLines === 0)
+    return;
+  const notice = droppedLines ? `[${new Date().toISOString()}] [magic-context][global] logger dropped ${droppedLines} ${droppedLines === 1 ? "line" : "lines"}: buffer exceeded ${MAX_BUFFERED_BYTES} bytes while writes were pending
+` : "";
+  try {
+    const data = capLogData(notice + buffer.join(""));
+    const logFile = getMagicContextLogPath();
+    ensureDir(logFile);
+    let currentSize = getCurrentLogSize(logFile);
+    const dataSize = Buffer.byteLength(data);
+    if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+      rotateLogFile(logFile, currentSize);
+      currentSize = 0;
+    }
+    fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
+    buffer = [];
+    bufferedBytes = 0;
+    droppedLines = 0;
+    activeLogFile = logFile;
+    activeLogSize = currentSize + dataSize;
+    flushesSinceSizeCheck++;
+  } catch (error) {
+    activeLogFile = null;
+    activeLogSize = null;
+    flushesSinceSizeCheck = 0;
+    recordSwallowedWrite(error);
+    boundBuffer();
+  }
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+function log(message, data) {
+  if (isTestEnv)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    const serialized = data === undefined ? "" : data instanceof Error ? ` ${sanitizeDiagnosticText(`${data.message}${data.stack ? `
+${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
+    const line = `[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}
+`;
+    buffer.push(line);
+    bufferedBytes += Buffer.byteLength(line);
+    boundBuffer();
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  } catch {}
+}
+function sessionLog(sessionId, message, data) {
+  log(`[magic-context][${sessionId}] ${message}`, data);
+}
+function getLoggerDiagnostics() {
+  return {
+    swallowedWriteCount,
+    lastErrorMessage,
+    lastErrorTime
+  };
+}
+function flushLogger() {
+  flush();
+}
+if (!isTestEnv) {
+  process.on("exit", flush);
+}
+
+export { setHarness, getHarness, harnessOwnsOpenCodeStore, getDataDir, ensureMmcArtifactGitignore, getProjectMagicContextHistorianDir, getMagicContextStorageDir, getLegacyOpenCodeMagicContextStorageDir, sanitizeDiagnosticText, log, sessionLog, getLoggerDiagnostics, flushLogger };