@devmarketplacenpm/devmp 0.1.1-beta.5

package/lib/markdown.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const { color } = require("./ui");
+const { wrap, displayWidth } = require("./tty/ansi");
+
+// The model streams markdown. Rendering it incrementally is only tractable
+// because markdown's block structure is line-oriented: once a line is
+// terminated by "\n" its block type can never change, so it can be rendered
+// and committed to scrollback permanently. The still-unterminated tail is
+// rendered separately into the live region, which is what makes text appear to
+// type itself without ever having to redraw finished output.
+
+const FENCE = /^\s*(```+|~~~+)\s*(\S*)/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const BULLET = /^(\s*)([-*+])\s+(.*)$/;
+const ORDERED = /^(\s*)(\d+)[.)]\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+const RULE = /^\s*([-*_])(\s*\1){2,}\s*$/;
+
+// Model output is untrusted. The agent reads the user's repository, so a
+// hostile file in it can steer what the model writes back — and any terminal
+// escape sequence that survives into this stream would let that text erase
+// lines the CLI has already printed, render itself invisible, or forge an
+// approval prompt. That would defeat the permission model the CLI's safety
+// rests on, so the sequences are stripped at the door.
+//
+// Stripping happens on the way in, before any buffering, which covers both the
+// lines committed to scrollback and the live region rendered from the same
+// buffer. The CLI's own colour is applied afterwards by the renderer, so no
+// legitimate styling is lost.
+const ANSI_SEQUENCE =
+  // CSI (colour, cursor, erase), OSC (window title), and lone two-byte escapes.
+  /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)?|[@-Z\\-_])/g;
+// Everything else in C0/C1 except tab and newline, which are meaningful here.
+// NUL matters twice over: it is also this module's code-span sentinel, so
+// letting it through would corrupt rendering as well.
+const CONTROL_CHARS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+
+/** Strip terminal control sequences from untrusted model text. */
+function sanitizeModelText(text) {
+  return String(text)
+    .replace(/\r\n?/g, "\n") // keep the line break, drop the overwrite
+    .replace(ANSI_SEQUENCE, "")
+    .replace(CONTROL_CHARS, "");
+}
+
+// Parks code-span contents so emphasis patterns cannot reach inside them.
+const SENTINEL = "\u0000";
+const SENTINEL_PATTERN = /\u0000(\d+)\u0000/g;
+
+/** Inline spans. Applied only to prose — never inside a fenced code block. */
+function renderInline(text) {
+  let out = String(text);
+  // Code spans first: their contents must not be re-parsed for emphasis.
+  const codeSpans = [];
+  out = out.replace(/`([^`]+)`/g, (_, code) => {
+    codeSpans.push(code);
+    return `${SENTINEL}${codeSpans.length - 1}${SENTINEL}`;
+  });
+
+  out = out.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) =>
+    `${color.cyan(label)} ${color.dim(`(${url})`)}`
+  );
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_, inner) => color.bold(inner));
+  out = out.replace(/__([^_]+)__/g, (_, inner) => color.bold(inner));
+  out = out.replace(/(^|[\s(])\*([^*\s][^*]*)\*/g, (_, lead, inner) =>
+    `${lead}${color.yellow(inner)}`
+  );
+  out = out.replace(/(^|[\s(])_([^_\s][^_]*)_/g, (_, lead, inner) =>
+    `${lead}${color.yellow(inner)}`
+  );
+  out = out.replace(/~~([^~]+)~~/g, (_, inner) => color.dim(inner));
+
+  return out.replace(SENTINEL_PATTERN, (_, index) =>
+    color.cyan(codeSpans[Number(index)])
+  );
+}
+
+function createMarkdownStream({ width = 80, indent = "  " } = {}) {
+  let buffer = "";
+  let inFence = false;
+  let fenceMarker = "";
+
+  const widthFn = typeof width === "function" ? width : () => width;
+  // Floor only at the point where wrapping stops being meaningful — a larger
+  // floor would silently ignore the real terminal width on narrow panes.
+  const inner = () => Math.max(8, widthFn() - displayWidth(indent));
+
+  /** Render one complete logical line into zero or more terminal lines. */
+  function renderLine(raw) {
+    const fence = raw.match(FENCE);
+    if (fence) {
+      const marker = fence[1];
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker[0];
+        const lang = fence[2];
+        return [
+          `${indent}${color.dim("┌─")}${
+            lang ? ` ${color.dim(lang)}` : ""
+          }`,
+        ];
+      }
+      if (marker[0] === fenceMarker) {
+        inFence = false;
+        fenceMarker = "";
+        return [`${indent}${color.dim("└─")}`];
+      }
+    }
+
+    if (inFence) {
+      // Code is never wrapped or restyled — a broken line is worse than one
+      // that runs past the edge and can still be copied intact.
+      return [`${indent}${color.dim("│")} ${color.green(raw)}`];
+    }
+
+    if (!raw.trim()) return [""];
+
+    if (RULE.test(raw)) {
+      return [`${indent}${color.dim("─".repeat(Math.min(40, inner())))}`];
+    }
+
+    const heading = raw.match(HEADING);
+    if (heading) {
+      const level = heading[1].length;
+      const body = renderInline(heading[2]);
+      const styled = level <= 2 ? color.bold(color.cyan(body)) : color.bold(body);
+      return wrap(styled, inner()).map((row) => `${indent}${row}`);
+    }
+
+    const quote = raw.match(QUOTE);
+    if (quote) {
+      return wrap(color.dim(renderInline(quote[1])), inner() - 2).map(
+        (row) => `${indent}${color.dim("▏")} ${row}`
+      );
+    }
+
+    const bullet = raw.match(BULLET);
+    if (bullet) {
+      const pad = `${indent}${bullet[1]}`;
+      const rows = wrap(renderInline(bullet[3]), inner() - bullet[1].length - 2);
+      return rows.map((row, index) =>
+        index === 0 ? `${pad}${color.cyan("•")} ${row}` : `${pad}  ${row}`
+      );
+    }
+
+    const ordered = raw.match(ORDERED);
+    if (ordered) {
+      const pad = `${indent}${ordered[1]}`;
+      const marker = `${ordered[2]}.`;
+      const rows = wrap(
+        renderInline(ordered[3]),
+        inner() - ordered[1].length - marker.length - 1
+      );
+      return rows.map((row, index) =>
+        index === 0
+          ? `${pad}${color.cyan(marker)} ${row}`
+          : `${pad}${" ".repeat(marker.length + 1)}${row}`
+      );
+    }
+
+    return wrap(renderInline(raw), inner()).map((row) => `${indent}${row}`);
+  }
+
+  return {
+    /** Feed a streamed delta; returns lines ready to commit to scrollback. */
+    push(delta) {
+      buffer += sanitizeModelText(delta);
+      const out = [];
+      let newline = buffer.indexOf("\n");
+      while (newline !== -1) {
+        const raw = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        out.push(...renderLine(raw));
+        newline = buffer.indexOf("\n");
+      }
+      return out;
+    },
+
+    /** The unterminated tail, rendered for display in the live region. */
+    partial() {
+      if (!buffer) return [];
+      if (inFence) return [`${indent}${color.dim("│")} ${color.green(buffer)}`];
+      return wrap(renderInline(buffer), inner()).map((row) => `${indent}${row}`);
+    },
+
+    /** Emit whatever is left when the stream ends. */
+    flush() {
+      if (!buffer) return [];
+      const raw = buffer;
+      buffer = "";
+      return renderLine(raw);
+    },
+
+    get open() {
+      return Boolean(buffer);
+    },
+  };
+}
+
+module.exports = { createMarkdownStream, renderInline, sanitizeModelText };

package/lib/mentions.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs/promises");
+
+const { resolveInside, isSecretPath } = require("./workspace");
+
+// `@path/to/file` in a prompt pulls that file into the turn.
+//
+// The agent can already read files on its own, but only after deciding it needs
+// to — which costs a round trip and sometimes never happens. Naming a file with
+// `@` is how someone says "this one, now", and it is the fastest way to give the
+// model the thing the question is actually about.
+//
+// A mention is only expanded when the path really exists in the workspace, which
+// is what keeps `@example.com`, `@scope/package` and `@Injectable` from being
+// mangled: they are not files, so they are left exactly as written.
+
+// Trailing punctuation is excluded from the path so "look at @app.js." works.
+const MENTION = /@([A-Za-z0-9._~\-/]+[A-Za-z0-9_~\-/])/g;
+
+const MAX_MENTION_BYTES = 32 * 1024;
+const MAX_MENTIONS = 10;
+
+/**
+ * Expand `@file` mentions in a prompt.
+ *
+ * Returns the rewritten prompt and the list of files that were attached, so the
+ * caller can tell the user what was sent rather than doing it silently.
+ */
+async function expandMentions(rootDir, prompt) {
+  const text = String(prompt ?? "");
+  const candidates = [...new Set([...text.matchAll(MENTION)].map((m) => m[1]))];
+  if (!candidates.length) return { prompt: text, attached: [] };
+
+  const attached = [];
+  const blocks = [];
+
+  for (const rel of candidates) {
+    if (attached.length >= MAX_MENTIONS) break;
+    if (isSecretPath(rel)) continue;
+
+    const target = resolveInside(rootDir, rel);
+    if (!target) continue;
+
+    let body;
+    try {
+      const stat = await fs.stat(target);
+      if (!stat.isFile()) continue;
+      const buf = await fs.readFile(target);
+      body = buf.subarray(0, MAX_MENTION_BYTES).toString("utf8");
+      if (buf.length > MAX_MENTION_BYTES) {
+        body += "\n… truncated";
+        attached.push({ path: rel, bytes: buf.length, truncated: true });
+      } else {
+        attached.push({ path: rel, bytes: buf.length, truncated: false });
+      }
+    } catch {
+      continue; // not a file we can read — leave the mention as written
+    }
+    blocks.push(`<file path="${rel}">\n${body}\n</file>`);
+  }
+
+  if (!blocks.length) return { prompt: text, attached: [] };
+  return { prompt: `${blocks.join("\n\n")}\n\n${text}`, attached };
+}
+
+module.exports = { expandMentions, MAX_MENTION_BYTES, MAX_MENTIONS };

package/lib/prompt.js

@@ -0,0 +1,140 @@
+"use strict";
+
+const readline = require("readline");
+const { formatUnifiedDiff, printUnifiedDiff } = require("./diff");
+
+// Approvals have two hosts:
+//
+//   legacy `devmp run` — no screen, no raw mode. Each prompt spins up its own
+//                        readline, exactly as it always has.
+//   interactive shell  — the composer owns stdin in raw mode for the whole
+//                        session, so a second readline here would fight it for
+//                        keystrokes. The shell installs a driver instead.
+//
+// The driver is process-wide because approvals are raised deep inside the
+// executor and command runner, which have no reference to the shell.
+
+let driver = null;
+
+/** Install the interactive host's approval driver (the shell owns stdin). */
+function setApprovalDriver(next) {
+  driver = next;
+}
+
+function clearApprovalDriver() {
+  driver = null;
+}
+
+/** True only when we can actually ask the user something interactively. */
+function isInteractive() {
+  return Boolean(driver) || Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function askLine(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(String(answer).trim().toLowerCase());
+    });
+  });
+}
+
+/**
+ * Ask how to handle overwriting an existing file. Resolves to one of:
+ *   'yes'  — overwrite this file
+ *   'no'   — skip this file
+ *   'all'  — overwrite this and every remaining existing file this run
+ */
+async function confirmOverwrite(relPath) {
+  if (driver) {
+    return driver.choose({
+      question: `Overwrite existing ${relPath}?`,
+      hint: "[y]es  [n]o  [a]ll",
+      choices: { y: "yes", n: "no", a: "all" },
+    });
+  }
+  const answer = await askLine(
+    `  overwrite existing ${relPath}? [y]es / [n]o / [a]ll: `
+  );
+  if (answer === "a" || answer === "all") return "all";
+  if (answer === "y" || answer === "yes") return "yes";
+  return "no";
+}
+
+/** Review one proposed edit with its real before/after diff. */
+async function confirmFileChange({ path, before, after }) {
+  const diff = formatUnifiedDiff({ path, before, after });
+  if (driver) {
+    // A brand-new file has no "before" worth diffing against — every line is
+    // an addition, so a full unified dump is noise that buries the prompt.
+    const isCreate = before === null || before === undefined;
+    driver.showDiff(diff, { isCreate, path });
+    return driver.choose({
+      question: `Apply this change to ${path}?`,
+      hint: "[y]es  [n]o  [a]ll edits this session",
+      choices: { y: "yes", n: "no", a: "all" },
+    });
+  }
+  printUnifiedDiff(diff);
+  const answer = await askLine(
+    "  apply this change? [y]es / [n]o / [a]ll edits this session: "
+  );
+  if (answer === "a" || answer === "all") return "all";
+  if (answer === "y" || answer === "yes") return "yes";
+  return "no";
+}
+
+/** Delete/move never inherit broad edit permission; the user sees the exact
+ * operation and must approve it explicitly. */
+async function confirmDestructive({ description, diffs = [] }) {
+  if (driver) {
+    driver.showText(description);
+    for (const diff of diffs) driver.showDiff(diff);
+    return driver.choose({
+      question: description,
+      hint: "[y]es  [N]o",
+      choices: { y: "yes", n: "no" },
+      defaultValue: "no",
+    });
+  }
+  console.log(`  ${description}`);
+  for (const diff of diffs) printUnifiedDiff(diff);
+  const answer = await askLine("  approve this destructive change? [y/N]: ");
+  return answer === "y" || answer === "yes" ? "yes" : "no";
+}
+
+/**
+ * Ask whether to run a command the agent requested on this machine. Resolves to
+ * 'yes' | 'no' | 'all' (every command this session) | 'exact' (this exact
+ * command this session). Default is always the safe 'no'.
+ */
+async function confirmCommand(command) {
+  if (driver) {
+    return driver.choose({
+      question: `Run this command on your machine?\n$ ${command}`,
+      hint: "[y]es  [n]o  [e]xact command this session  [a]ll commands",
+      choices: { y: "yes", n: "no", e: "exact", a: "all" },
+    });
+  }
+  const answer = await askLine(
+    `  run command on your machine?\n    $ ${command}\n  [y]es / [n]o / [e]xact command this session / [a]ll commands: `
+  );
+  if (answer === "a" || answer === "all") return "all";
+  if (answer === "e" || answer === "exact") return "exact";
+  if (answer === "y" || answer === "yes") return "yes";
+  return "no";
+}
+
+module.exports = {
+  isInteractive,
+  confirmOverwrite,
+  confirmFileChange,
+  confirmDestructive,
+  confirmCommand,
+  setApprovalDriver,
+  clearApprovalDriver,
+};

package/lib/routes.js

@@ -0,0 +1,27 @@
+"use strict";
+
+// The versioned platform surface. One place that knows where the server lives,
+// so a path cannot drift between the HTTP client, the WebSocket client and the
+// status card — and so a future /platform/v2 is a one-line change here.
+//
+// `session.apiBaseUrl` already ends in `/api` (the server's global prefix);
+// `platform/v1` is the versioned product surface within it.
+
+const PLATFORM_BASE = "/platform/v1";
+
+/** POST — one-shot NDJSON build (`devmp run`). */
+function agentRunUrl(apiBaseUrl) {
+  return `${apiBaseUrl}${PLATFORM_BASE}/agent/run`;
+}
+
+/** WebSocket — the live tunnel and interactive sessions. */
+function agentWsUrl(apiBaseUrl) {
+  return `${apiBaseUrl.replace(/^http/i, "ws")}${PLATFORM_BASE}/agent/ws`;
+}
+
+/** GET — token allowance and rate-limit headroom for the current user. */
+function usageUrl(apiBaseUrl) {
+  return `${apiBaseUrl}${PLATFORM_BASE}/me/usage`;
+}
+
+module.exports = { PLATFORM_BASE, agentRunUrl, agentWsUrl, usageUrl };

package/lib/session.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs/promises');
+const os = require('os');
+const path = require('path');
+
+// Same on-disk location the existing device-auth client uses, so a login from
+// either tool is shared. Overridable for tests/demos via DEVMP_CLI_CONFIG.
+const AUTH_DIR = '.devmarketplace';
+const AUTH_FILE = 'cli-auth.json';
+const CONVERSATION_FILE = 'cli-conversations.json';
+
+function sessionPath() {
+  return (
+    process.env.DEVMP_CLI_CONFIG || path.join(os.homedir(), AUTH_DIR, AUTH_FILE)
+  );
+}
+
+function conversationPath() {
+  return (
+    process.env.DEVMP_CLI_SESSIONS ||
+    path.join(os.homedir(), AUTH_DIR, CONVERSATION_FILE)
+  );
+}
+
+async function loadSession() {
+  try {
+    const raw = await fs.readFile(sessionPath(), 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && parsed.accessToken ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function saveSession(session) {
+  const file = sessionPath();
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(session, null, 2)}\n`, {
+    encoding: 'utf8',
+    mode: 0o600,
+  });
+  await fs.chmod(file, 0o600).catch(() => undefined);
+}
+
+/**
+ * Remove the saved session. Returns true if a file was removed, false if there
+ * was nothing to remove.
+ *
+ * Only "it was not there" is swallowed. A permission or read-only-filesystem
+ * error must reach the caller: someone logging out on a shared machine has to
+ * be told when the credentials are still on disk, not reassured that they are
+ * gone.
+ */
+async function clearSession() {
+  try {
+    await fs.unlink(sessionPath());
+    return true;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function workspaceKey(apiBaseUrl, rootDir) {
+  return `${String(apiBaseUrl)}\n${path.resolve(rootDir)}`;
+}
+
+async function loadConversation(apiBaseUrl, rootDir) {
+  try {
+    const raw = await fs.readFile(conversationPath(), 'utf8');
+    const parsed = JSON.parse(raw);
+    const value = parsed?.workspaces?.[workspaceKey(apiBaseUrl, rootDir)];
+    return value && typeof value === 'object' ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+async function saveConversation(apiBaseUrl, rootDir, conversation) {
+  const file = conversationPath();
+  let document = { version: 1, workspaces: {} };
+  try {
+    const parsed = JSON.parse(await fs.readFile(file, 'utf8'));
+    if (parsed && parsed.workspaces) document = parsed;
+  } catch {
+    /* first saved conversation */
+  }
+  document.version = 1;
+  document.workspaces[workspaceKey(apiBaseUrl, rootDir)] = conversation;
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${JSON.stringify(document, null, 2)}\n`, {
+    encoding: 'utf8',
+    mode: 0o600,
+  });
+  await fs.chmod(file, 0o600).catch(() => undefined);
+}
+
+module.exports = {
+  sessionPath,
+  conversationPath,
+  loadSession,
+  saveSession,
+  clearSession,
+  loadConversation,
+  saveConversation,
+};