@devmarketplacenpm/devmp 0.1.1-beta.5

package/lib/tty/screen.js

@@ -0,0 +1,167 @@
+"use strict";
+
+const { cursor, rowsFor, totalRows, displayWidth } = require("./ansi");
+
+// The screen owns every byte written to the terminal during an interactive
+// session, and splits it into two regions:
+//
+//   scrollback — finished output. Painted exactly once, never redrawn, so the
+//                user keeps native terminal scroll, copy and search over it.
+//   live       — the bottom few rows (status line, composer, queued messages).
+//                Erased and repainted on every frame.
+//
+// Anything that writes to stdout behind the screen's back will corrupt the
+// row accounting, which is why the shell routes all output through `write`.
+
+function createScreen({ stream = process.stdout } = {}) {
+  const isTty = Boolean(stream.isTTY);
+
+  let liveLines = [];
+  let liveCaret = null;
+  // Rows the live region currently occupies, and where the cursor sits within
+  // it (0 = first row of the live region).
+  let paintedRows = 0;
+  let cursorRow = 0;
+  let closed = false;
+
+  // Row accounting must use the terminal's real width. Clamping it to some
+  // comfortable minimum would make us predict a different wrap point than the
+  // terminal actually uses, and every erase after that would be off by rows.
+  const columns = () => Math.max(1, stream.columns || 80);
+  const rows = () => Math.max(2, stream.rows || 24);
+
+  /** Keep the live region strictly shorter than the viewport so the cursor-up
+   *  arithmetic can never address a row that has already scrolled away. */
+  function clamp(lines) {
+    const limit = rows() - 1;
+    const width = columns();
+    let visible = lines;
+    while (visible.length > 1 && totalRows(visible, width) > limit) {
+      visible = visible.slice(1);
+    }
+    return visible;
+  }
+
+  /** Wrapped-row offset and column of the caret inside the live region. */
+  function caretPosition(lines, caret) {
+    if (!caret) return null;
+    const width = columns();
+    const lineIndex = Math.min(Math.max(caret.line | 0, 0), lines.length - 1);
+    let row = 0;
+    for (let i = 0; i < lineIndex; i += 1) row += rowsFor(lines[i], width);
+    const col = Math.max(0, caret.column | 0);
+    return { row: row + Math.floor(col / width), column: col % width };
+  }
+
+  function erase() {
+    if (paintedRows === 0) return;
+    stream.write(cursor.toColumn0 + cursor.up(cursorRow) + cursor.eraseDown);
+    paintedRows = 0;
+    cursorRow = 0;
+  }
+
+  function paint() {
+    if (liveLines.length === 0) {
+      paintedRows = 0;
+      cursorRow = 0;
+      return;
+    }
+    const visible = clamp(liveLines);
+    const width = columns();
+
+    // No trailing newline: the last row must not reserve an extra blank line
+    // at the bottom of the viewport.
+    stream.write(cursor.hide + visible.join("\n"));
+    paintedRows = totalRows(visible, width);
+    cursorRow = paintedRows - 1;
+
+    const caret = caretPosition(visible, liveCaret);
+    if (caret) {
+      const up = Math.max(0, paintedRows - 1 - caret.row);
+      stream.write(cursor.up(up) + cursor.toColumn0 + cursor.right(caret.column));
+      cursorRow = caret.row;
+      stream.write(cursor.show);
+    }
+  }
+
+  const api = {
+    get isTty() {
+      return isTty;
+    },
+    get columns() {
+      return columns();
+    },
+    get rows() {
+      return rows();
+    },
+
+    /** Commit finished output to scrollback, above the live region. */
+    write(text) {
+      if (closed) return;
+      const body = String(text);
+      if (!body) return;
+      if (!isTty) {
+        stream.write(body.endsWith("\n") ? body : `${body}\n`);
+        return;
+      }
+      erase();
+      stream.write(body.endsWith("\n") ? body : `${body}\n`);
+      paint();
+    },
+
+    /** Commit a list of already-rendered logical lines to scrollback. */
+    writeLines(lines) {
+      if (!lines || lines.length === 0) return;
+      api.write(lines.join("\n"));
+    },
+
+    /**
+     * Replace the live region. `caret` is `{ line, column }` in logical-line
+     * coordinates with `column` measured in display cells.
+     */
+    setLive(lines, caret = null) {
+      if (closed || !isTty) return;
+      liveLines = Array.isArray(lines) ? lines : [lines];
+      liveCaret = caret;
+      erase();
+      paint();
+    },
+
+    clearLive() {
+      if (closed || !isTty) return;
+      liveLines = [];
+      liveCaret = null;
+      erase();
+    },
+
+    /** Repaint after a terminal resize; the old geometry is no longer valid. */
+    resize() {
+      if (closed || !isTty || liveLines.length === 0) return;
+      // `paintedRows` was measured at the old width. The terminal has since
+      // reflowed the same content into a different number of rows, so erasing
+      // with the stale count clears too few of them and leaves a torn copy of
+      // the live region above the new one. Re-measure against the new width
+      // first, and assume the cursor rides at the bottom of the reflowed
+      // block — which is where it sits in every terminal that reflows at all.
+      const visible = clamp(liveLines);
+      paintedRows = totalRows(visible, columns());
+      cursorRow = Math.max(0, paintedRows - 1);
+      erase();
+      paint();
+    },
+
+    close() {
+      if (closed) return;
+      closed = true;
+      if (!isTty) return;
+      liveLines = [];
+      liveCaret = null;
+      erase();
+      stream.write(cursor.show);
+    },
+  };
+
+  return api;
+}
+
+module.exports = { createScreen, displayWidth };

package/lib/ui.js

@@ -0,0 +1,174 @@
+"use strict";
+
+// Minimal ANSI styling. Disabled when NO_COLOR is set or output is not a TTY,
+// so piped/CI output stays clean.
+//
+// Two families live here on purpose:
+//   `fmt.*`  build strings, for anything routed through the interactive
+//            screen (which must own every write to keep its row accounting).
+//   bare fns print directly, for the one-shot commands that have no screen.
+
+const { displayWidth, stripAnsi } = require("./tty/ansi");
+
+const enabled = !process.env.NO_COLOR && process.stdout.isTTY;
+
+function style(open, close) {
+  return (text) =>
+    enabled ? `\x1b[${open}m${text}\x1b[${close}m` : String(text);
+}
+
+const color = {
+  bold: style(1, 22),
+  dim: style(2, 22),
+  red: style(31, 39),
+  green: style(32, 39),
+  yellow: style(33, 39),
+  blue: style(34, 39),
+  cyan: style(36, 39),
+  gray: style(90, 39),
+};
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const fmt = {
+  banner: () =>
+    color.bold(color.cyan("devmp")) + color.dim(" — server-side coding agent"),
+  success: (msg) => `${color.green("✓")} ${msg}`,
+  warn: (msg) => `${color.yellow("!")} ${msg}`,
+  fail: (msg) => `${color.red("✗")} ${msg}`,
+  line: (label, value) => `  ${color.dim(String(label).padEnd(11))} ${value}`,
+  // Same pair, without the leading indent — for rows inside a box, which
+  // supplies its own padding.
+  pair: (label, value) => `${color.dim(String(label).padEnd(10))} ${value}`,
+  section: (title) => ["", color.bold(title)],
+};
+
+/**
+ * Render a bordered card. Returns lines rather than printing so the caller can
+ * route them through the screen. `width` is measured in display columns, so
+ * styled labels inside the card still line up.
+ */
+/** Cut a row down to `width` columns. */
+function fitToWidth(value, width) {
+  const text = String(value);
+  if (displayWidth(text) <= width) return text;
+  // A hard cut, not a word wrap: these rows are label/value pairs, and wrapping
+  // drops the value entirely when it is a single long token such as a path.
+  // Styling goes with the cut, because slicing through an escape sequence would
+  // spill raw codes onto the screen — and a trimmed row is only ever the
+  // fallback for a terminal too narrow to show it in full.
+  const plain = stripAnsi(text);
+  const limit = Math.max(1, width - 1); // leave a column for the ellipsis
+  let out = "";
+  let used = 0;
+  for (const char of plain) {
+    const charWidth = displayWidth(char);
+    if (used + charWidth > limit) break;
+    out += char;
+    used += charWidth;
+  }
+  return `${out}…`;
+}
+
+function box(lines, { title, minWidth = 24, maxWidth = 76 } = {}) {
+  // Follow the terminal when it is narrower than the default. Rows were never
+  // trimmed, so a long workspace path pushed its own border off the right edge
+  // and the card read as broken — which is exactly where users look when
+  // something has already gone wrong.
+  const available = process.stdout.columns
+    ? Math.max(minWidth, process.stdout.columns - 4)
+    : maxWidth;
+  const cap = Math.min(maxWidth, available);
+
+  const fitted = lines.map((item) => fitToWidth(item, cap));
+  const widest = Math.max(
+    minWidth,
+    title ? displayWidth(title) + 4 : 0,
+    ...fitted.map((item) => displayWidth(item))
+  );
+  const width = Math.min(cap, widest);
+  lines = fitted;
+  // Body rows are `│ ` + content + padding + ` │`, i.e. width + 4 columns. The
+  // titled top edge is `╭─ ` + title + ` ` + dashes + `╮`, so it needs
+  // width - title - 1 dashes to land on the same column as everything else.
+  const top = title
+    ? `╭─ ${title} ${"─".repeat(Math.max(1, width - displayWidth(title) - 1))}╮`
+    : `╭${"─".repeat(width + 2)}╮`;
+  const out = [color.dim(top)];
+  for (const item of lines) {
+    const pad = Math.max(0, width - displayWidth(item));
+    out.push(`${color.dim("│")} ${item}${" ".repeat(pad)} ${color.dim("│")}`);
+  }
+  out.push(color.dim(`╰${"─".repeat(width + 2)}╯`));
+  return out;
+}
+
+function formatNumber(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return "—";
+  return Math.max(0, Math.round(n)).toLocaleString("en-US");
+}
+
+function formatDate(value) {
+  if (!value) return "unknown";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "unknown";
+  return date.toLocaleDateString("en-US", {
+    month: "long",
+    day: "numeric",
+    year: "numeric",
+  });
+}
+
+function formatDuration(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+
+function banner() {
+  console.log(fmt.banner());
+}
+
+function section(title) {
+  console.log("");
+  console.log(color.bold(title));
+}
+
+function info(msg) {
+  console.log(msg);
+}
+
+function success(msg) {
+  console.log(fmt.success(msg));
+}
+
+function warn(msg) {
+  console.log(fmt.warn(msg));
+}
+
+function fail(msg) {
+  console.error(fmt.fail(msg));
+}
+
+function line(label, value) {
+  console.log(fmt.line(label, value));
+}
+
+module.exports = {
+  color,
+  fmt,
+  box,
+  SPINNER_FRAMES,
+  formatNumber,
+  formatDate,
+  formatDuration,
+  banner,
+  section,
+  info,
+  success,
+  warn,
+  fail,
+  line,
+};

package/lib/version.js

@@ -0,0 +1,134 @@
+"use strict";
+
+// Client version negotiation.
+//
+// The agent lives on the server, so most releases reach users the moment the
+// server deploys — nothing to install. Only this client (terminal UI, file
+// writing, tunnel protocol) ships through npm, and CLI users famously never
+// run `npm update -g`. So the server tells us, on every authenticated call and
+// on every session handshake, which client it expects:
+//
+//   latest — newest published client; we nudge, nothing more
+//   min    — oldest client this server still speaks to; below it we refuse
+//
+// The refusal is the important half: when the tunnel protocol changes, an old
+// client would otherwise fail in some unreadable way mid-turn. Better to say
+// so up front, in one line the user can act on.
+//
+// Both fields are optional. A server that sends neither (an older deploy) is
+// handled exactly as before — no notice, no gate.
+
+const { version: CURRENT, name: PACKAGE } = require("../package.json");
+
+/** Split "1.2.3-beta.4" into comparable parts. Returns null if unparseable. */
+function parse(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(
+    String(value || "").trim(),
+  );
+  if (!match) return null;
+  return {
+    main: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ? match[4].split(".") : [],
+  };
+}
+
+/** Compare two prerelease identifiers the way semver precedence requires. */
+function comparePreParts(a, b) {
+  const aNum = /^\d+$/.test(a);
+  const bNum = /^\d+$/.test(b);
+  if (aNum && bNum) return Math.sign(Number(a) - Number(b));
+  if (aNum) return -1; // numeric identifiers rank below alphanumeric
+  if (bNum) return 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * Semver precedence: -1 if a < b, 1 if a > b, 0 if equal.
+ * Returns 0 for anything unparseable so a malformed server value can never
+ * lock a working client out.
+ */
+function compare(a, b) {
+  const left = parse(a);
+  const right = parse(b);
+  if (!left || !right) return 0;
+
+  for (let i = 0; i < 3; i += 1) {
+    if (left.main[i] !== right.main[i]) {
+      return left.main[i] < right.main[i] ? -1 : 1;
+    }
+  }
+
+  // 1.0.0-beta precedes 1.0.0; a release outranks any prerelease of itself.
+  if (left.pre.length && !right.pre.length) return -1;
+  if (!left.pre.length && right.pre.length) return 1;
+
+  for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i += 1) {
+    const l = left.pre[i];
+    const r = right.pre[i];
+    if (l === undefined) return -1; // fewer identifiers = lower precedence
+    if (r === undefined) return 1;
+    const cmp = comparePreParts(l, r);
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+}
+
+// What the server last told us. Any transport may fill this in — the HTTP
+// usage call, the WebSocket handshake — and every surface reads the same copy.
+let reported = null;
+
+/** Record a `{ latest, min }` block from a server payload. Ignores junk. */
+function record(info) {
+  if (!info || typeof info !== "object") return;
+  const latest = typeof info.latest === "string" ? info.latest : null;
+  const min = typeof info.min === "string" ? info.min : null;
+  if (!latest && !min) return;
+  reported = { latest, min };
+}
+
+/** Test seam: drop anything a previous call recorded. */
+function reset() {
+  reported = null;
+}
+
+function state() {
+  const latest = reported?.latest ?? null;
+  const min = reported?.min ?? null;
+  return {
+    current: CURRENT,
+    latest,
+    min,
+    updateAvailable: Boolean(latest) && compare(CURRENT, latest) < 0,
+    blocked: Boolean(min) && compare(CURRENT, min) < 0,
+  };
+}
+
+/** One line for the end of a session. Null when there is nothing to say. */
+function updateNotice() {
+  const { current, latest, updateAvailable, blocked } = state();
+  if (blocked || !updateAvailable) return null;
+  return `Update available: ${current} → ${latest}   npm i -g ${PACKAGE}`;
+}
+
+/**
+ * The hard gate. Returns a ready-to-print message when this client is too old
+ * for the server, otherwise null.
+ */
+function blockedMessage() {
+  const { current, min, blocked } = state();
+  if (!blocked) return null;
+  return (
+    `This devmp is too old for the server (you have ${current}, ` +
+    `it needs ${min} or newer).\n  Update with: npm i -g ${PACKAGE}`
+  );
+}
+
+module.exports = {
+  CURRENT,
+  compare,
+  record,
+  reset,
+  state,
+  updateNotice,
+  blockedMessage,
+};