mednotes-opencode 0.1.0

package/.opencode/mednotes/scripts/hooks/mednotes_hook/hook_errors.mjs

@@ -0,0 +1,120 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { pruneHookErrorFiles } from "./retention.mjs";
+import { clampInt } from "./runtime.mjs";
+
+const SCHEMA = "medical-notes-workbench.agent-hook-error.v1";
+const MAX_ERROR_CHARS = clampInt(process.env.MEDNOTES_HOOK_MAX_ERROR_CHARS, 8 * 1024, 512, 64 * 1024);
+
+export async function recordHookError({
+  mode = "",
+  type = "hook_internal_error",
+  severity = "warning",
+  payload = {},
+  error = null,
+  message = "",
+  details = {},
+} = {}) {
+  try {
+    const event = buildHookError({ mode, type, severity, payload, error, message, details });
+    const dir = path.join(feedbackRoot(), "hook-errors");
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, `${event.recorded_at.replace(/[:.]/g, "-")}-${event.error_id}.json`);
+    const tmp = `${file}.tmp`;
+    await fs.writeFile(tmp, `${JSON.stringify(event, null, 2)}\n`, "utf8");
+    await fs.rename(tmp, file);
+    await pruneHookErrorFiles(dir);
+  } catch {
+    // Last-resort fail-open: hook error capture must never create a hook error loop.
+  }
+}
+
+export function buildHookError({ mode, type, severity, payload, error, message, details }) {
+  const safePayload = payload && typeof payload === "object" ? payload : {};
+  const err = error instanceof Error ? error : null;
+  return {
+    schema: SCHEMA,
+    error_id: crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString("hex"),
+    recorded_at: new Date().toISOString(),
+    mode: cleanCode(mode || "unknown"),
+    type: cleanCode(type || "hook_internal_error"),
+    severity: cleanCode(severity || "warning"),
+    hook_event_name: String(safePayload.hook_event_name || ""),
+    tool_name: String(safePayload.tool_name || safePayload.toolName || safePayload.name || ""),
+    session_id: String(safePayload.session_id || ""),
+    transcript_path: compactPath(String(safePayload.transcript_path || "")),
+    cwd: compactPath(String(safePayload.cwd || process.cwd())),
+    message: redactOperationalText(message || err?.message || String(error || "unknown hook error"), MAX_ERROR_CHARS),
+    stack_tail: err?.stack ? tail(redactOperationalText(err.stack, MAX_ERROR_CHARS), MAX_ERROR_CHARS) : "",
+    details: sanitizeDetails(details),
+  };
+}
+
+function sanitizeDetails(value, depth = 0) {
+  if (depth > 4) return "[max-depth]";
+  if (!value || typeof value !== "object") {
+    return typeof value === "string" ? redactOperationalText(value, 500) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => sanitizeDetails(item, depth + 1));
+  }
+  const out = {};
+  for (const [key, item] of Object.entries(value).slice(0, 30)) {
+    const lower = key.toLowerCase();
+    if (["token", "auth_token", "api_key", "apikey", "secret", "password", "authorization", "bearer"].includes(lower)) {
+      out[key] = "[redacted]";
+    } else if (["content", "markdown", "html", "raw_chat", "note_text"].includes(lower)) {
+      out[key] = `[${lower} omitted]`;
+    } else {
+      out[key] = sanitizeDetails(item, depth + 1);
+    }
+  }
+  return out;
+}
+
+function cleanCode(value) {
+  return (
+    String(value || "unknown")
+      .replace(/[^a-zA-Z0-9_.-]/g, "_")
+      .toLowerCase()
+      .slice(0, 80) || "unknown"
+  );
+}
+
+function feedbackRoot() {
+  const configured = process.env.MEDNOTES_FEEDBACK_DIR || process.env.MEDICAL_NOTES_FEEDBACK_DIR;
+  if (configured) return configured;
+  return path.join(os.homedir(), ".gemini", "medical-notes-workbench", "feedback");
+}
+
+function compactPath(value) {
+  const text = String(value || "");
+  if (!text) return "";
+  const home = os.homedir();
+  return text.startsWith(home) ? `~${text.slice(home.length)}` : text;
+}
+
+function redactOperationalText(value, maxChars) {
+  let text = String(value || "");
+  text = text.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[email]");
+  text = text.replace(
+    /\b(api[_-]?key|token|secret|password|authorization|bearer)(\s*[:=]\s*)(["']?)[^\s"']+/gi,
+    "$1$2[redacted]",
+  );
+  text = text.replace(/(--(?:api-key|auth-token|token|secret|password)\s+)([^\s"']+)/gi, "$1[redacted]");
+  text = text.replace(/https?:\/\/[^\s)>"]+/g, (url) => {
+    const index = url.indexOf("?");
+    return index === -1 ? url : `${url.slice(0, index)}?[redacted]`;
+  });
+  text = text.replace(/\b[A-Za-z0-9_=-]{36,}\b/g, "[redacted-token]");
+  if (text.length > maxChars) return `${text.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
+  return text;
+}
+
+function tail(value, maxChars) {
+  const text = String(value || "");
+  return text.length > maxChars ? text.slice(text.length - maxChars) : text;
+}

package/.opencode/mednotes/scripts/hooks/mednotes_hook/retention.mjs

@@ -0,0 +1,114 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { clampInt } from "./runtime.mjs";
+
+function retentionHours(kind) {
+  const specific =
+    kind === "error"
+      ? process.env.MEDNOTES_HOOK_ERROR_RETENTION_HOURS
+      : process.env.MEDNOTES_HOOK_EVENT_RETENTION_HOURS;
+  return clampInt(specific ?? process.env.MEDNOTES_HOOK_RETENTION_HOURS, 24, 1, 168);
+}
+
+function retentionPolicy(kind) {
+  return {
+    maxFiles: clampInt(
+      kind === "error" ? process.env.MEDNOTES_HOOK_ERROR_MAX_FILES : process.env.MEDNOTES_HOOK_EVENT_MAX_FILES,
+      kind === "error" ? 25 : 50,
+      0,
+      1000,
+    ),
+    retentionHours: retentionHours(kind),
+  };
+}
+
+export async function pruneHookEventFiles(dir) {
+  await pruneJsonFiles(dir, retentionPolicy("event"));
+}
+
+export async function pruneHookErrorFiles(dir) {
+  await pruneJsonFiles(dir, retentionPolicy("error"));
+}
+
+export function pruneHookEventFilesSync(dir) {
+  pruneJsonFilesSync(dir, retentionPolicy("event"));
+}
+
+async function pruneJsonFiles(dir, policy) {
+  try {
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const filePath = path.join(dir, entry.name);
+      try {
+        const stat = await fsp.stat(filePath);
+        files.push({ path: filePath, name: entry.name, mtimeMs: stat.mtimeMs });
+      } catch {
+        // Best effort only.
+      }
+    }
+    await pruneEntries(files, policy, (filePath) => fsp.unlink(filePath));
+  } catch {
+    // Retention cleanup is observability-only. Never fail a hook because of it.
+  }
+}
+
+function pruneJsonFilesSync(dir, policy) {
+  try {
+    const files = [];
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const filePath = path.join(dir, name);
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) files.push({ path: filePath, name, mtimeMs: stat.mtimeMs });
+      } catch {
+        // Best effort only.
+      }
+    }
+    pruneEntriesSync(files, policy, (filePath) => fs.unlinkSync(filePath));
+  } catch {
+    // Retention cleanup is observability-only. Never fail a hook because of it.
+  }
+}
+
+async function pruneEntries(files, policy, unlink) {
+  const victims = retentionVictims(files, policy);
+  for (const item of victims) {
+    try {
+      await unlink(item.path);
+    } catch {
+      // Another process may have cleaned it already.
+    }
+  }
+}
+
+function pruneEntriesSync(files, policy, unlink) {
+  const victims = retentionVictims(files, policy);
+  for (const item of victims) {
+    try {
+      unlink(item.path);
+    } catch {
+      // Another process may have cleaned it already.
+    }
+  }
+}
+
+function retentionVictims(files, policy) {
+  const cutoffMs = Date.now() - policy.retentionHours * 60 * 60 * 1000;
+  const sorted = [...files].sort((left, right) => right.mtimeMs - left.mtimeMs || right.name.localeCompare(left.name));
+  const victims = [];
+  const survivors = [];
+  for (const item of sorted) {
+    if (item.mtimeMs < cutoffMs) {
+      victims.push(item);
+    } else {
+      survivors.push(item);
+    }
+  }
+  victims.push(...survivors.slice(Math.max(0, policy.maxFiles)));
+  return victims;
+}

package/.opencode/mednotes/scripts/hooks/mednotes_hook/runtime.mjs

@@ -0,0 +1,174 @@
+export const ankiConnectUrl = (process.env.ANKI_CONNECT_URL || "http://127.0.0.1:8765").replace(/\/+$/, "");
+export const stdinTimeoutMs = clampInt(process.env.MEDNOTES_HOOK_STDIN_TIMEOUT_MS, 250, 100, 2000);
+export const stdinHardTimeoutMs = clampInt(process.env.MEDNOTES_HOOK_STDIN_HARD_TIMEOUT_MS, 2500, 250, 15000);
+export const ankiStartTimeoutMs = clampInt(process.env.MEDNOTES_ANKI_START_TIMEOUT_MS, 8000, 1000, 15000);
+export const ankiAutoStart = /^(1|true|yes)$/i.test(process.env.MEDNOTES_ANKI_AUTO_START || "");
+const EAGER_PARSE_MAX_CHARS = 64 * 1024;
+
+export function clampInt(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.trunc(parsed)));
+}
+
+export function quiet() {
+  return { suppressOutput: true };
+}
+
+export function allow(extra = {}) {
+  return { decision: "allow", ...extra };
+}
+
+export function deny(reason, extra = {}) {
+  return {
+    decision: "deny",
+    reason: String(reason || "Operação bloqueada pela política de segurança do vault."),
+    ...extra,
+  };
+}
+
+export function writeJson(output) {
+  process.stdout.write(JSON.stringify(output || quiet()));
+}
+
+export function tryParseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text || "{}") };
+  } catch {
+    return { ok: false, value: {} };
+  }
+}
+
+export async function readPayload(timeoutMs = stdinTimeoutMs) {
+  return (await readPayloadResult(timeoutMs)).payload;
+}
+
+export function readPayloadResult(timeoutMs = stdinTimeoutMs, hardTimeoutMs = stdinHardTimeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let text = "";
+    let idleTimer;
+    let hardTimer;
+
+    const finish = (payload, error = null) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(idleTimer);
+      clearTimeout(hardTimer);
+      try {
+        process.stdin.pause();
+        process.stdin.unref?.();
+        process.stdin.removeAllListeners("data");
+        process.stdin.removeAllListeners("end");
+        process.stdin.removeAllListeners("error");
+      } catch {
+        // Best effort: the hook must still return JSON even with unusual stdin.
+      }
+      resolve({
+        payload: payload && typeof payload === "object" ? payload : {},
+        error,
+      });
+    };
+
+    const parseOrError = (raw, options = {}) => {
+      const parsed = tryParseJson(raw.trim());
+      if (parsed.ok) {
+        finish(parsed.value);
+      } else {
+        const reason = options.reason || "unknown";
+        finish(
+          {},
+          {
+            type: "invalid_stdin_json",
+            message: "Hook stdin was not valid JSON.",
+            details: {
+              reason,
+              stdin_bytes: Buffer.byteLength(raw || "", "utf8"),
+            },
+          },
+        );
+      }
+    };
+
+    const parseWhenComplete = () => {
+      if (!shouldAttemptParse(text)) return false;
+      const parsed = tryParseJson(text.trim());
+      if (!parsed.ok) return false;
+      finish(parsed.value);
+      return true;
+    };
+
+    const handleIdleTimeout = (reason = "timeout") => {
+      if (settled) return;
+      if (!text.trim()) {
+        finish({});
+      } else if (isSmallPayload(text)) {
+        parseOrError(text, { reason });
+      } else {
+        if (parseWhenComplete()) return;
+        // Gemini can split or truncate large hook stdin. Partial large JSON is
+        // a transport limitation, not a workflow or model error to report.
+      }
+    };
+
+    const armIdleTimeout = (reason = "timeout") => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => handleIdleTimeout(reason), timeoutMs);
+    };
+
+    armIdleTimeout("timeout");
+    hardTimer = setTimeout(() => {
+      if (settled) return;
+      if (!text.trim()) {
+        finish({});
+      } else if (isSmallPayload(text)) {
+        parseOrError(text, { reason: "hard_timeout" });
+      } else if (parseWhenComplete()) {
+        return;
+      } else {
+        finish({});
+      }
+    }, hardTimeoutMs);
+
+    if (process.stdin.isTTY) {
+      finish({});
+      return;
+    }
+
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      text += chunk;
+      armIdleTimeout("inactivity_timeout");
+      parseWhenComplete();
+    });
+    process.stdin.on("end", () => {
+      if (text.trim()) {
+        parseOrError(text, { reason: "end" });
+      } else {
+        finish({});
+      }
+    });
+    process.stdin.on("error", (error) =>
+      finish(
+        {},
+        {
+          type: "stdin_read_error",
+          message: error instanceof Error ? error.message : String(error || "Hook stdin read failed."),
+          details: { stdin_bytes: Buffer.byteLength(text || "", "utf8") },
+        },
+      ),
+    );
+    process.stdin.resume();
+  });
+}
+
+function shouldAttemptParse(raw) {
+  const trimmed = String(raw || "").trim();
+  if (!trimmed) return true;
+  if (isSmallPayload(trimmed)) return true;
+  return trimmed.endsWith("}") || trimmed.endsWith("]");
+}
+
+function isSmallPayload(raw) {
+  return String(raw || "").trim().length <= EAGER_PARSE_MAX_CHARS;
+}