@moor-sh/mcp 0.27.1 → 0.27.2

package/src/tail-utf8.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { tailUtf8 } from "./tail-utf8";
-
-describe("tailUtf8", () => {
-  test("returns the string unchanged when under maxBytes", () => {
-    const r = tailUtf8("hello", 100);
-    expect(r.tail).toBe("hello");
-    expect(r.storedBytes).toBe(5);
-    expect(r.trimmed).toBe(false);
-  });
-
-  test("returns the last maxBytes bytes for ASCII input", () => {
-    const r = tailUtf8("0123456789", 4);
-    expect(r.tail).toBe("6789");
-    expect(r.storedBytes).toBe(10);
-    expect(r.trimmed).toBe(true);
-  });
-
-  test("returns an empty string when maxBytes is 0", () => {
-    const r = tailUtf8("hello", 0);
-    expect(r.tail).toBe("");
-    expect(r.storedBytes).toBe(5);
-    expect(r.trimmed).toBe(true);
-  });
-
-  test("preserves complete trailing multi-byte codepoints", () => {
-    // "café" = c(1) a(1) f(1) é(2) = 5 bytes. Cap at 4 → trim "c", landing
-    // on "a" boundary; result "afé" (4 bytes).
-    const r = tailUtf8("café", 4);
-    expect(r.tail).toBe("afé");
-    expect(r.storedBytes).toBe(5);
-    expect(r.trimmed).toBe(true);
-    expect(r.tail).not.toContain("\ufffd");
-  });
-
-  test("aligns to a codepoint boundary when the cut falls inside a 2-byte sequence", () => {
-    // "héllo" = h(1) é(2) l(1) l(1) o(1) = 6 bytes. Cap at 4 → start at
-    // byte 2, which is the continuation of é. Align forward to "llo" (3 bytes).
-    const r = tailUtf8("héllo", 4);
-    expect(r.tail).toBe("llo");
-    expect(r.storedBytes).toBe(6);
-    expect(r.tail).not.toContain("\ufffd");
-  });
-
-  test("aligns to a codepoint boundary inside a 3-byte sequence", () => {
-    // "€€€" = 9 bytes (each € = 3 bytes). Cap at 4 → start at byte 5, which
-    // is a continuation. Align forward to start of last € → "€" (3 bytes).
-    const r = tailUtf8("€€€", 4);
-    expect(r.tail).toBe("€");
-    expect(r.storedBytes).toBe(9);
-    expect(r.tail).not.toContain("\ufffd");
-  });
-
-  test("aligns inside a 4-byte sequence (surrogate pair codepoint)", () => {
-    // "🌍🌍" = 8 bytes (each emoji = 4 bytes). Cap at 5 → start at byte 3,
-    // continuation. Align forward to start of last emoji → "🌍" (4 bytes).
-    const r = tailUtf8("🌍🌍", 5);
-    expect(r.tail).toBe("🌍");
-    expect(r.storedBytes).toBe(8);
-    expect(r.tail).not.toContain("\ufffd");
-  });
-
-  test("reports storedBytes as the original UTF-8 byte length, not JS char length", () => {
-    // "🌍" is 1 codepoint but 4 UTF-8 bytes (and 2 UTF-16 code units in JS).
-    const r = tailUtf8("🌍", 100);
-    expect(r.storedBytes).toBe(4);
-    expect(r.tail.length).toBe(2); // JS string length counts UTF-16 code units
-  });
-});

package/src/tail-utf8.ts

@@ -1,25 +0,0 @@
-// Byte-aware UTF-8 tail-trim used by moor_exec_status (#44). The MCP tool
-// can't return the full API tail (up to 64 KiB per stream) inline because
-// large responses blow agent token budgets. Caller picks how many bytes per
-// stream they want; the trim is UTF-8 safe — the result never starts mid-
-// codepoint, which would cause TextDecoder to emit U+FFFD at the head.
-
-export function tailUtf8(
-  s: string,
-  maxBytes: number,
-): { tail: string; storedBytes: number; trimmed: boolean } {
-  const bytes = new TextEncoder().encode(s);
-  const storedBytes = bytes.length;
-  if (storedBytes <= maxBytes) return { tail: s, storedBytes, trimmed: false };
-  if (maxBytes === 0) return { tail: "", storedBytes, trimmed: true };
-  // Start at the offset that leaves maxBytes bytes; walk forward past any
-  // UTF-8 continuation bytes (10xxxxxx) so the decoded tail begins on a
-  // codepoint boundary.
-  let start = storedBytes - maxBytes;
-  while (start < storedBytes && (bytes[start] & 0xc0) === 0x80) start++;
-  return {
-    tail: new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(start)),
-    storedBytes,
-    trimmed: true,
-  };
-}

package/src/update-audit-render.test.ts

@@ -1,171 +0,0 @@
-// Tests for the moor_update_audit renderer. Pure functions — no
-// network, no DB. Lives next to its consumer so the formatting
-// operators actually see has direct test coverage.
-
-import { describe, expect, test } from "bun:test";
-import {
-  DEFAULT_LOG_TAIL_BYTES,
-  fmtDuration,
-  MAX_LOG_TAIL_BYTES,
-  renderAuditList,
-  renderAuditRow,
-  shortDigest,
-  tailLog,
-  type UpdateAuditApiRow,
-} from "./update-audit-render";
-
-function row(overrides: Partial<UpdateAuditApiRow> = {}): UpdateAuditApiRow {
-  return {
-    id: 1,
-    state: "success",
-    started_at: "2026-05-25 00:00:00",
-    duration_ms: 50_000,
-    from_digest: `sha256:${"a".repeat(64)}`,
-    to_digest: `sha256:${"b".repeat(64)}`,
-    prev_image_id: `sha256:${"c".repeat(64)}`,
-    backup_path: "/app/data/moor.db.backup-1",
-    error_log: null,
-    rollback_error: null,
-    ...overrides,
-  };
-}
-
-describe("shortDigest", () => {
-  test("formats sha256:<64 hex> as sha256:<7>…<7>", () => {
-    expect(shortDigest(`sha256:${"a".repeat(64)}`)).toBe(
-      `sha256:${"a".repeat(7)}…${"a".repeat(7)}`,
-    );
-  });
-  test("strips the repo prefix from repo@sha256:... form", () => {
-    expect(shortDigest(`ghcr.io/caiopizzol/moor@sha256:${"b".repeat(64)}`)).toBe(
-      `sha256:${"b".repeat(7)}…${"b".repeat(7)}`,
-    );
-  });
-  test("non-digest input passes through unchanged", () => {
-    expect(shortDigest("sha256:short")).toBe("sha256:short");
-    expect(shortDigest("not-a-digest")).toBe("not-a-digest");
-  });
-  test("null/undefined → '(none)'", () => {
-    expect(shortDigest(null)).toBe("(none)");
-    expect(shortDigest(undefined)).toBe("(none)");
-  });
-});
-
-describe("fmtDuration", () => {
-  test("null → em dash", () => expect(fmtDuration(null)).toBe("—"));
-  test("sub-second values in ms", () => expect(fmtDuration(420)).toBe("420ms"));
-  test("seconds for [1s, 60s)", () => expect(fmtDuration(50_000)).toBe("50s"));
-  test("minutes+seconds at and above 60s", () => {
-    expect(fmtDuration(60_000)).toBe("1m0s");
-    expect(fmtDuration(125_000)).toBe("2m5s");
-  });
-});
-
-describe("tailLog", () => {
-  test("null/undefined → '' (no field rendered by caller)", () => {
-    expect(tailLog(null, 100)).toBe("");
-    expect(tailLog(undefined, 100)).toBe("");
-  });
-  test("short string passes through unchanged", () => {
-    expect(tailLog("short", 100)).toBe("short");
-  });
-  test("long string is tail-truncated with a visible marker", () => {
-    const big = "x".repeat(10_000);
-    const out = tailLog(big, 1000);
-    expect(out).toContain("[...9000 earlier bytes truncated]");
-    expect(out.endsWith("x".repeat(1000))).toBe(true);
-  });
-  test("tail_bytes=0 elides the field body entirely with a sized marker", () => {
-    const out = tailLog("hello world", 0);
-    expect(out).toBe("[...11 bytes elided (tail_bytes=0)]");
-  });
-  test("tail_bytes=0 on null/undefined → ''", () => {
-    expect(tailLog(null, 0)).toBe("");
-    expect(tailLog(undefined, 0)).toBe("");
-  });
-});
-
-describe("renderAuditRow", () => {
-  test("success: includes id, state, duration, from/to, backup; no error_log line", () => {
-    const out = renderAuditRow(row());
-    expect(out).toContain("audit_id=1");
-    expect(out).toContain("state=success");
-    expect(out).toContain("duration=50s");
-    expect(out).toContain("from: sha256:aaaaaaa");
-    expect(out).toContain("to: sha256:bbbbbbb");
-    expect(out).toContain("prev_image_id: sha256:ccccccc");
-    expect(out).toContain("backup: /app/data/moor.db.backup-1");
-    expect(out).not.toContain("error_log");
-    expect(out).not.toContain("rollback_error");
-  });
-
-  test("rolled_back: error_log shown, rollback_error omitted", () => {
-    const out = renderAuditRow(row({ state: "rolled_back", error_log: "health check failed" }));
-    expect(out).toContain("state=rolled_back");
-    expect(out).toContain("error_log: health check failed");
-    expect(out).not.toContain("rollback_error");
-  });
-
-  test("rollback_failed: BOTH error_log and rollback_error rendered", () => {
-    const out = renderAuditRow(
-      row({
-        state: "rollback_failed",
-        error_log: "apply up failed",
-        rollback_error: "rollback tag failed",
-      }),
-    );
-    expect(out).toContain("state=rollback_failed");
-    expect(out).toContain("error_log: apply up failed");
-    expect(out).toContain("rollback_error: rollback tag failed");
-  });
-
-  test("tail_bytes truncates long error_log per-field with marker", () => {
-    const long = "X".repeat(5000);
-    const out = renderAuditRow(row({ error_log: long }), { tail_bytes: 100 });
-    expect(out).toContain("[...4900 earlier bytes truncated]");
-  });
-
-  test("tail_bytes=0 elides log body but keeps the field line", () => {
-    const out = renderAuditRow(row({ error_log: "anything" }), { tail_bytes: 0 });
-    expect(out).toContain("error_log: [...");
-    expect(out).toContain("bytes elided (tail_bytes=0)");
-    expect(out).not.toContain("anything");
-  });
-
-  test("tail_bytes is clamped to MAX_LOG_TAIL_BYTES", () => {
-    // No assertion against the actual byte count; just verify the
-    // constant is honored and the function tolerates an over-cap input.
-    expect(MAX_LOG_TAIL_BYTES).toBeGreaterThan(DEFAULT_LOG_TAIL_BYTES);
-    const long = "Y".repeat(MAX_LOG_TAIL_BYTES + 1000);
-    const out = renderAuditRow(row({ error_log: long }), { tail_bytes: 999_999 });
-    expect(out).toContain("earlier bytes truncated");
-  });
-
-  test("prev_image_id null → no prev line", () => {
-    const out = renderAuditRow(row({ prev_image_id: null }));
-    expect(out).not.toContain("prev_image_id");
-  });
-
-  test("backup_path null → no backup line", () => {
-    const out = renderAuditRow(row({ backup_path: null }));
-    expect(out).not.toContain("backup:");
-  });
-
-  test("non-digest from/to (rare edge) passes through via shortDigest fallback", () => {
-    const out = renderAuditRow(row({ from_digest: "weird", to_digest: null }));
-    expect(out).toContain("from: weird");
-    expect(out).toContain("to: (none)");
-  });
-});
-
-describe("renderAuditList", () => {
-  test("empty → friendly hint", () => {
-    expect(renderAuditList([])).toContain("no update attempts recorded yet");
-  });
-  test("multi-row separated by blank line", () => {
-    const out = renderAuditList([row({ id: 2 }), row({ id: 1 })]);
-    expect(out.split("\n\n").length).toBe(2);
-    expect(out).toContain("audit_id=2");
-    expect(out).toContain("audit_id=1");
-  });
-});

package/src/update-audit-render.ts

@@ -1,94 +0,0 @@
-// #80 PR #6: pure renderers for moor_update_audit. Lives next to its
-// consumer (the MCP tool) so the formatting that operators actually
-// see has direct test coverage.
-//
-// Each row renders as a multi-line block with id, state, duration,
-// digest deltas, prev_image_id, backup path, and per-field tailed
-// error_log / rollback_error.
-
-/** API row shape returned by GET /api/server/update/audit. Subset of
- *  the full DB row — only what the renderer needs. */
-export type UpdateAuditApiRow = {
-  id: number;
-  state: string;
-  started_at: string;
-  duration_ms: number | null;
-  from_digest: string | null;
-  to_digest: string | null;
-  prev_image_id: string | null;
-  backup_path: string | null;
-  error_log: string | null;
-  rollback_error: string | null;
-};
-
-export const DEFAULT_LOG_TAIL_BYTES = 4096;
-export const MAX_LOG_TAIL_BYTES = 16384;
-
-/** Pure: short-form a sha256 digest for compact rendering (first 7 +
- *  last 7). Accepts both raw `sha256:<hex>` and `repo@sha256:<hex>`
- *  forms; returns the input unchanged on anything else. */
-export function shortDigest(s: string | null | undefined): string {
-  if (!s) return "(none)";
-  const m = s.match(/^(?:[^@]+@)?sha256:([0-9a-f]{64})$/);
-  if (!m) return s;
-  const hex = m[1];
-  return `sha256:${hex.slice(0, 7)}…${hex.slice(-7)}`;
-}
-
-/** Pure: human-readable duration. Mirrors the format moor_runs uses. */
-export function fmtDuration(ms: number | null): string {
-  if (ms == null) return "—";
-  if (ms < 1000) return `${ms}ms`;
-  const s = Math.round(ms / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  const rem = s % 60;
-  return `${m}m${rem}s`;
-}
-
-/** Pure: tail-truncate a string to maxBytes with a visible marker.
- *  maxBytes=0 means omit the field body entirely (returns the marker
- *  alone). Used per-field for error_log + rollback_error so a
- *  crashed update with a long log doesn't blow up the token budget. */
-export function tailLog(s: string | null | undefined, maxBytes: number): string {
-  if (s == null) return "";
-  if (maxBytes <= 0) {
-    const enc = new TextEncoder();
-    return `[...${enc.encode(s).length} bytes elided (tail_bytes=0)]`;
-  }
-  const enc = new TextEncoder();
-  const bytes = enc.encode(s);
-  if (bytes.length <= maxBytes) return s;
-  const dropped = bytes.length - maxBytes;
-  const tail = new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(dropped));
-  return `[...${dropped} earlier bytes truncated]\n${tail}`;
-}
-
-/** Pure: render one audit row. tail_bytes applies separately to
- *  error_log and rollback_error; absent fields are skipped. */
-export function renderAuditRow(row: UpdateAuditApiRow, opts: { tail_bytes?: number } = {}): string {
-  const tail = Math.min(opts.tail_bytes ?? DEFAULT_LOG_TAIL_BYTES, MAX_LOG_TAIL_BYTES);
-  const lines: string[] = [
-    `audit_id=${row.id} state=${row.state} duration=${fmtDuration(row.duration_ms)} started=${row.started_at}`,
-    `  from: ${shortDigest(row.from_digest)} → to: ${shortDigest(row.to_digest)}`,
-  ];
-  if (row.prev_image_id) lines.push(`  prev_image_id: ${shortDigest(row.prev_image_id)}`);
-  if (row.backup_path) lines.push(`  backup: ${row.backup_path}`);
-  if (row.error_log) lines.push(`  error_log: ${tailLog(row.error_log, tail)}`);
-  if (row.rollback_error) {
-    lines.push(`  rollback_error: ${tailLog(row.rollback_error, tail)}`);
-  }
-  return lines.join("\n");
-}
-
-/** Pure: render a list of rows separated by a blank line. Empty list
- *  returns the documented "no updates yet" string. */
-export function renderAuditList(
-  rows: UpdateAuditApiRow[],
-  opts: { tail_bytes?: number } = {},
-): string {
-  if (rows.length === 0) {
-    return "no update attempts recorded yet. Run moor_update_apply to start one.";
-  }
-  return rows.map((r) => renderAuditRow(r, opts)).join("\n\n");
-}