zc2 0.0.46

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
import { ago } from "../lib/format";
import { parse, type Level } from "../lib/logline";
import { isAgentError, logs as logsApi, type LogFile, type LogTail } from "../lib/agent";
import { Button, ScreenHead } from "../components/ui";

const cx = (...c: (string | false | null | undefined)[]) => c.filter(Boolean).join(" ");
const TAILS = [200, 500, 2000] as const;
const DEFAULT_FILE = "agent.log";

const bytes = (n: number): string =>
  n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} KB` : `${(n / 1024 / 1024).toFixed(1)} MB`;

const errMsg = (e: unknown): { code: string | null; message: string } =>
  isAgentError(e)
    ? { code: e.code, message: e.code === "admin_only" ? "Log access is for admin accounts." : e.message }
    : { code: null, message: String(e) };


const badge: Record<Level, string> = {
  error: "bg-wine/15 text-wine-bright",
  warn: "bg-warn/15 text-warn",
  info: "bg-raised text-fg-dim",
  debug: "bg-raised text-fg-dim",
  other: "",
};
const LABEL: Record<Level, string> = { error: "ERROR", warn: "WARN", info: "INFO", debug: "DEBUG", other: "" };

const clock = (ts: string | null): string => {
  if (!ts) return "";
  const m = /T(\d\d:\d\d:\d\d)/.exec(ts);
  return m ? m[1]! : ts;
};

function highlight(line: string, q: string): ReactNode {
  if (!q) return line;
  const lo = line.toLowerCase();
  const needle = q.toLowerCase();
  const out: ReactNode[] = [];
  let at = 0;
  for (let i = lo.indexOf(needle); i !== -1; i = lo.indexOf(needle, at)) {
    if (i > at) out.push(line.slice(at, i));
    out.push(
      <mark key={i} className="rounded-xs bg-warn/30 text-inherit">
        {line.slice(i, i + needle.length)}
      </mark>,
    );
    at = i + needle.length;
  }
  out.push(line.slice(at));
  return out;
}

/** This machine's zc logs (agent, broker, workers). Admin accounts only. */
export function Logs() {
  const [files, setFiles] = useState<LogFile[] | null>(null);
  const [selected, setSelected] = useState<string>(DEFAULT_FILE);
  const [tailN, setTailN] = useState<number>(500);
  const [tail, setTail] = useState<LogTail | null>(null);
  const [error, setError] = useState<{ code: string | null; message: string } | null>(null);
  const [filter, setFilter] = useState("");
  const [levels, setLevels] = useState<Set<Level>>(new Set());
  const [follow, setFollow] = useState(false);
  const [wrap, setWrap] = useState(true);
  const [copied, setCopied] = useState(false);
  const viewer = useRef<HTMLDivElement>(null);
  const pinned = useRef(true);

  const loadFiles = useCallback(async () => {
    try {
      const r = await logsApi.list();
      setFiles(r.files);
      setError(null);
      setSelected((cur) => (r.files.some((f) => f.name === cur) ? cur : (r.files[0]?.name ?? cur)));
    } catch (e) {
      setError(errMsg(e));
    }
  }, []);

  // Each tail request takes a number; only the latest may land, so a slow
  // answer for the previous tab or tail size never replaces the current one.
  const tailSeq = useRef(0);
  const loadTail = useCallback(async () => {
    const seq = ++tailSeq.current;
    try {
      const res = await logsApi.tail(selected, tailN);
      if (seq !== tailSeq.current) return;
      setTail(res);
      setError(null);
    } catch (e) {
      if (seq !== tailSeq.current) return;
      setError(errMsg(e));
    }
  }, [selected, tailN]);

  const refresh = useCallback(() => {
    void loadFiles();
    void loadTail();
  }, [loadFiles, loadTail]);

  useEffect(() => {
    void loadFiles();
  }, [loadFiles]);
  useEffect(() => {
    pinned.current = true;
    setTail(null);
  }, [selected]);
  useEffect(() => {
    void loadTail();
  }, [loadTail]);
  useEffect(() => {
    if (!follow) return;
    const t = setInterval(refresh, 2000);
    return () => clearInterval(t);
  }, [follow, refresh]);

  const entries = useMemo(() => (tail?.lines ?? []).map((l, i) => parse(l, i + 1)), [tail]);
  const counts = useMemo(() => {
    const c: Record<Level, number> = { error: 0, warn: 0, info: 0, debug: 0, other: 0 };
    for (const e of entries) c[e.level]++;
    return c;
  }, [entries]);
  const q = filter.trim();
  const shown = useMemo(() => {
    const lq = q.toLowerCase();
    return entries.filter((e) => (levels.size === 0 || levels.has(e.level)) && (!lq || e.raw.toLowerCase().includes(lq)));
  }, [entries, levels, q]);

  // Keep the viewer at the bottom while the user hasn't scrolled up.
  useEffect(() => {
    const el = viewer.current;
    if (el && pinned.current) el.scrollTop = el.scrollHeight;
  }, [shown]);

  const toggleLevel = (l: Level) =>
    setLevels((cur) => {
      const next = new Set(cur);
      if (!next.delete(l)) next.add(l);
      return next;
    });

  const jumpToError = () => {
    const el = viewer.current;
    if (!el) return;
    const rows = el.querySelectorAll<HTMLElement>('[data-level="error"]');
    const last = rows[rows.length - 1];
    if (last) {
      pinned.current = false;
      last.scrollIntoView({ block: "center" });
    }
  };

  const copy = async () => {
    try {
      await navigator.clipboard.writeText(shown.map((e) => e.raw).join("\n"));
      setCopied(true);
      setTimeout(() => setCopied(false), 1500);
    } catch {
      /* clipboard unavailable */
    }
  };

  const file = files?.find((f) => f.name === selected);
  const adminOnly = error?.code === "admin_only";

  return (
    <>
      <ScreenHead title="Logs" sub="This machine's zc agent, broker and worker logs. Secrets are redacted.">
        <Button size="sm" onClick={refresh}>
          Refresh
        </Button>
      </ScreenHead>

      {error && (adminOnly || !tail) && (
        <div role="alert" className="rounded-r-md border-l-[3px] border-wine bg-wine/10 px-4 py-2.5 text-[12.5px]">
          <b className="font-semibold">{adminOnly ? "Admins only" : (error.code ?? "Couldn't read logs")}</b>
          <div className="text-fg-dim">{error.message}</div>
        </div>
      )}

      {!adminOnly && (
        <div className="overflow-hidden rounded-md border border-hairline bg-surface">
          {/* file tabs */}
          <div role="tablist" aria-label="Log files" className="flex flex-wrap gap-1 border-b border-hairline bg-raised/50 px-2 pt-2">
            {files === null ? (
              <span className="px-2 pb-2 text-[12px] text-fg-dim">Loading…</span>
            ) : files.length === 0 ? (
              <span className="px-2 pb-2 text-[12px] text-fg-dim">No log files yet.</span>
            ) : (
              files.map((f) => (
                <button
                  key={f.name}
                  role="tab"
                  aria-selected={f.name === selected}
                  onClick={() => setSelected(f.name)}
                  className={cx(
                    "rounded-t-sm border border-b-0 px-3 py-1.5 font-mono text-[12px]",
                    f.name === selected
                      ? "border-hairline bg-surface font-semibold text-wine-bright"
                      : "border-transparent text-fg-dim hover:text-fg",
                  )}
                >
                  {f.name}
                </button>
              ))
            )}
          </div>

          {/* toolbar */}
          <div className="grid gap-2 border-b border-hairline px-3 py-2.5">
            <div className="flex flex-wrap items-center gap-2">
              <input
                type="search"
                value={filter}
                onChange={(e) => setFilter(e.target.value)}
                placeholder="Filter lines…"
                aria-label="Filter lines"
                className="min-w-[160px] flex-1 rounded-sm border border-hairline bg-bg px-2.5 py-1.5 text-[12.5px] outline-none focus:border-wine"
              />
              <div className="flex gap-1" role="group" aria-label="Levels">
                {(["error", "warn", "info"] as const).map((l) => (
                  <button
                    key={l}
                    onClick={() => toggleLevel(l)}
                    aria-pressed={levels.has(l)}
                    className={cx(
                      "rounded-full border px-2.5 py-0.5 text-[11.5px] font-medium tnum",
                      levels.has(l) ? "border-wine bg-wine/10 text-wine-bright" : "border-hairline text-fg-dim hover:bg-raised",
                    )}
                  >
                    {LABEL[l]} {counts[l]}
                  </button>
                ))}
              </div>
              <select
                value={tailN}
                onChange={(e) => setTailN(Number(e.target.value))}
                aria-label="Lines to load"
                className="rounded-sm border border-hairline bg-bg px-2 py-1.5 text-[12.5px]"
              >
                {TAILS.map((n) => (
                  <option key={n} value={n}>
                    Last {n}
                  </option>
                ))}
              </select>
            </div>
            <div className="flex flex-wrap items-center gap-3 text-[12px]">
              <label className="flex items-center gap-1.5">
                <input type="checkbox" checked={follow} onChange={(e) => setFollow(e.target.checked)} />
                Follow
              </label>
              <label className="flex items-center gap-1.5">
                <input type="checkbox" checked={wrap} onChange={(e) => setWrap(e.target.checked)} />
                Wrap lines
              </label>
              <Button size="sm" onClick={jumpToError} disabled={counts.error === 0}>
                Jump to last error
              </Button>
              <Button size="sm" onClick={copy} disabled={shown.length === 0}>
                {copied ? "Copied" : "Copy"}
              </Button>
              <span className="ml-auto text-fg-dim tnum">
                {tail ? `${shown.length}${shown.length !== entries.length ? ` of ${entries.length}` : ""} lines` : ""}
                {file ? ` · ${bytes(file.size)} · updated ${ago(file.modified)}` : ""}
                {tail?.truncated ? " · earlier lines not shown" : ""}
              </span>
            </div>
            {error && tail && <div className="text-[12px] text-wine-bright">{error.message}</div>}
          </div>

          {/* viewer */}
          <div
            ref={viewer}
            onScroll={(e) => {
              const el = e.currentTarget;
              pinned.current = el.scrollHeight - el.scrollTop - el.clientHeight < 24;
            }}
            role="log"
            aria-label={selected}
            className="h-[min(58vh,540px)] overflow-auto bg-bg font-mono text-[11.5px] leading-[1.6]"
          >
            {tail === null && !error ? (
              <div className="p-3 text-fg-dim">Loading…</div>
            ) : shown.length === 0 ? (
              <div className="p-3 text-fg-dim">{entries.length === 0 ? "This file is empty." : "No lines match the filters."}</div>
            ) : (
              <div className={wrap ? "" : "w-max min-w-full"}>
                {shown.map((e) => (
                  <div
                    key={e.n}
                    data-level={e.level}
                    className={cx(
                      "grid grid-cols-[44px_62px_52px_1fr] items-baseline gap-x-2 border-l-2 px-2 py-px hover:bg-raised",
                      e.level === "error" ? "border-wine bg-wine/10" : e.level === "warn" ? "border-warn bg-warn/10" : "border-transparent",
                    )}
                  >
                    <span className="select-none text-right text-fg-dim/60 tnum">{e.n}</span>
                    <span className="text-fg-dim tnum">{clock(e.ts)}</span>
                    <span>
                      {e.level !== "other" && (
                        <span className={cx("rounded-xs px-1 text-[10px] font-semibold", badge[e.level])}>{LABEL[e.level]}</span>
                      )}
                    </span>
                    <span
                      className={cx(
                        wrap ? "whitespace-pre-wrap break-all" : "whitespace-pre",
                        e.level === "error" && "font-medium text-wine-bright",
                        e.level === "warn" && "text-warn",
                      )}
                    >
                      {highlight(e.msg, q)}
                    </span>
                  </div>
                ))}
              </div>
            )}
          </div>
        </div>
      )}
    </>
  );
}