ryugi-artifacts 1.32.0 → 1.33.0

package/dist/cli.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/main.ts
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process4 = require("node:child_process");
 var import_node_util = require("node:util");
 
 // src/cli/paths.ts
@@ -516,17 +516,467 @@ function config(options, emit) {
   return 0;
 }
 
-// src/cli/start.ts
+// src/cli/monitor-view.ts
+var import_node_os2 = __toESM(require("node:os"), 1);
+var REFRESH_SECONDS = 2;
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var INVERSE = "\x1B[7m";
+var RESET = "\x1B[0m";
+var HELP = "\u2191\u2193 select  o open  c copy URL  l logs  x stop  X stop all safe  q quit";
+var COLUMNS = [["PORT", 6], ["PID", 8], ["UP", 7], ["TABS", 5], ["IDLE", 7], ["VERSION", 13]];
+var FIXED = 2 + COLUMNS.reduce((sum, [, width]) => sum + width + 2, 0);
+var TAGS_WIDTH = 26;
+function duration(ms) {
+  const minutes = Math.max(0, Math.floor(ms / 6e4));
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h${minutes % 60 ? `${minutes % 60}m` : ""}`;
+  return `${Math.floor(hours / 24)}d${hours % 24 ? `${hours % 24}h` : ""}`;
+}
+var shortPath = (project, home = import_node_os2.default.homedir()) => project === home || project.startsWith(`${home}/`) ? `~${project.slice(home.length)}` : project;
+function tags(row) {
+  return [row.safeToStop && "safe to stop", row.oldRelease && "old release", row.status === "no-status" && "no status"].filter(Boolean);
+}
+var initialView = () => ({ mode: "list", selected: 0, confirm: null, target: null, message: null });
+var fit = (text2, width) => text2.length > width ? text2.slice(0, width) : text2;
+var pad = (text2, width) => fit(text2, width).padEnd(width);
+var cutLeft = (text2, width) => text2.length > width ? `\u2026${text2.slice(text2.length - width + 1)}` : text2;
+function header(left, right, width) {
+  const gap = width - left.length - right.length;
+  return `${BOLD}${fit(gap >= 2 ? `${left}${" ".repeat(gap)}${right}` : left, width)}${RESET}`;
+}
+function cells(row, now) {
+  return [
+    row.port === null ? "-" : String(row.port),
+    String(row.pid),
+    duration(now - row.startedAt),
+    row.clients === null ? "-" : String(row.clients),
+    row.lastActivity === null ? "-" : duration(now - row.lastActivity),
+    row.version ?? "-"
+  ];
+}
+function footer(rows, state, home) {
+  if (state.confirm === "stop" && state.target) return `Stop ${shortPath(state.target, home)}? y to confirm`;
+  if (state.confirm === "stop-safe") {
+    const count = rows.filter((row) => row.safeToStop).length;
+    return `Stop ${count} server${count === 1 ? "" : "s"} that ${count === 1 ? "is" : "are"} safe to stop? y to confirm`;
+  }
+  return state.message ?? HELP;
+}
+function renderList(rows, state, screen) {
+  const { width, height, now, home } = screen;
+  const count = `${rows.length} server${rows.length === 1 ? "" : "s"} \xB7 refreshes every ${REFRESH_SECONDS}s`;
+  const lines = [header("ryugi-artifacts monitor", count, width)];
+  if (!rows.length) {
+    lines.push("", fit("No artifacts servers are running.", width), "");
+  } else {
+    const projectWidth = Math.max(12, width - FIXED - TAGS_WIDTH);
+    const columns = ["  ", pad("PROJECT", projectWidth), ...COLUMNS.map(([name, w]) => `  ${pad(name, w)}`)].join("");
+    lines.push(`${DIM}${fit(columns.trimEnd(), width)}${RESET}`);
+    const visible = Math.max(1, height - 4);
+    const first = Math.min(Math.max(0, state.selected - visible + 1), Math.max(0, rows.length - visible));
+    rows.slice(first, first + visible).forEach((row, offset) => {
+      const selected = first + offset === state.selected;
+      const text2 = [
+        selected ? "\u203A " : "  ",
+        pad(cutLeft(shortPath(row.project, home), projectWidth), projectWidth),
+        ...cells(row, now).map((cell, i) => `  ${pad(cell, COLUMNS[i][1])}`),
+        tags(row).length ? `  ${tags(row).join(", ")}` : ""
+      ].join("");
+      const line = fit(text2.trimEnd(), width);
+      lines.push(selected ? `${INVERSE}${line}${RESET}` : line);
+    });
+    lines.push("");
+  }
+  lines.push(`${DIM}${fit(footer(rows, state, home), width)}${RESET}`);
+  return lines;
+}
+function renderLog(row, text2, screen) {
+  const { width, height, home } = screen;
+  const lines = [header(`Log \xB7 ${shortPath(row.project, home)}`, row.log, width)];
+  const body = text2 === null ? ["No log file: this server runs in the foreground, so its output is in the terminal that started it."] : text2.replace(/\n+$/, "").split("\n").slice(-Math.max(1, height - 2));
+  lines.push(...body.map((line) => fit(line, width)));
+  lines.push(`${DIM}${fit("Esc back  Ctrl+C quit", width)}${RESET}`);
+  return lines;
+}
+function handleKey(state, key, rows) {
+  if (key.ctrl && key.name === "c") return { state, action: { type: "quit" } };
+  const next = { ...state, confirm: null, target: null, message: null };
+  if (state.mode === "log") return { state: key.name === "escape" || key.name === "q" ? { ...next, mode: "list" } : state };
+  if (state.confirm) {
+    if (key.name !== "y") return { state: next };
+    const targets = state.confirm === "stop" ? rows.filter((row) => row.project === state.target) : rows.filter((row) => row.safeToStop);
+    if (targets.length) return { state: next, action: { type: "stop", rows: targets } };
+    return { state: { ...next, message: state.target ? `${shortPath(state.target)} is no longer running.` : "Nothing is safe to stop any more." } };
+  }
+  const selected = rows[state.selected];
+  if (key.sequence === "X" || key.name === "x" && key.shift) {
+    if (rows.some((row) => row.safeToStop)) return { state: { ...next, confirm: "stop-safe" } };
+    return { state: { ...next, message: "Nothing is safe to stop: every server has an open tab or was used in the last 30 minutes." } };
+  }
+  switch (key.name) {
+    case "q":
+      return { state, action: { type: "quit" } };
+    case "up":
+    case "k":
+      return { state: { ...next, selected: Math.max(0, state.selected - 1) } };
+    case "down":
+    case "j":
+      return { state: { ...next, selected: Math.min(Math.max(0, rows.length - 1), state.selected + 1) } };
+    case "o":
+    case "c":
+      if (!selected) return { state: next };
+      if (!selected.url) return { state: { ...next, message: "This server has no URL yet." } };
+      return { state: next, action: { type: key.name === "o" ? "open" : "copy", row: selected } };
+    case "l":
+      return { state: selected ? { ...next, mode: "log" } : next };
+    case "x":
+      return { state: selected ? { ...next, confirm: "stop", target: selected.project } : next };
+    default:
+      return { state: next };
+  }
+}
+
+// src/cli/monitor-ui.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
-// src/server/artifact-address.ts
+// src/server/lifecycle.ts
+var DEFAULT_IDLE_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+var DEFAULT_LIFECYCLE_CHECK_MS = 60 * 1e3;
+function browserLauncher(platform, url) {
+  if (platform === "darwin") return { bin: "open", args: [url] };
+  if (platform === "win32") return { bin: "cmd", args: ["/c", "start", '""', url] };
+  if (platform === "linux" || platform === "freebsd" || platform === "openbsd") return { bin: "xdg-open", args: [url] };
+  return null;
+}
+
+// src/cli/servers.ts
+var import_node_path8 = __toESM(require("node:path"), 1);
+
+// src/server/registry.ts
 var import_node_crypto = __toESM(require("node:crypto"), 1);
 var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
+function registryDir(env = process.env, platform = process.platform, uid = process.getuid?.() ?? -1, tmpdir = import_node_os3.default.tmpdir()) {
+  if (env.RYUGI_RUNTIME_DIR) return import_node_path7.default.join(env.RYUGI_RUNTIME_DIR, "servers");
+  if (platform === "win32") return import_node_path7.default.join(tmpdir, "ryugi", "servers");
+  return `/tmp/ryugi-${uid}/servers`;
+}
+var fileFor = (dir, project) => import_node_path7.default.join(dir, `${import_node_crypto.default.createHash("sha256").update(project).digest("hex").slice(0, 16)}.json`);
+function verifyDir(dir) {
+  if (process.platform === "win32") return;
+  for (const target of [import_node_path7.default.dirname(dir), dir]) {
+    const stat = import_node_fs7.default.lstatSync(target);
+    if (!stat.isDirectory() || stat.uid !== process.getuid() || stat.mode & 18) throw new Error(`Unsafe registry directory: ${target}`);
+  }
+}
+function readEntry(file) {
+  try {
+    const value = JSON.parse(import_node_fs7.default.readFileSync(file, "utf8"));
+    if (typeof value.project !== "string" || typeof value.root !== "string" || typeof value.serverId !== "string") return null;
+    if (!Number.isInteger(value.pid) || !Number.isFinite(value.startedAt)) return null;
+    if (value.root !== import_node_path7.default.join(value.project, ".ryugi", "artifacts")) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function readEntries(dir) {
+  let names;
+  try {
+    verifyDir(dir);
+    names = import_node_fs7.default.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => name.endsWith(".json")).flatMap((name) => readEntry(import_node_path7.default.join(dir, name)) ?? []);
+}
+function removeEntry(dir, entry) {
+  const file = fileFor(dir, entry.project);
+  if (readEntry(file)?.serverId === entry.serverId) import_node_fs7.default.rmSync(file, { force: true });
+}
+
+// src/cli/servers.ts
+var SAFE_IDLE_MS = 30 * 6e4;
+var STATUS_TIMEOUT_MS = 1e3;
+var safeToStop = (status, now) => !!status && status.clients === 0 && now - status.lastActivity >= SAFE_IDLE_MS;
+async function fetchStatus(url) {
+  const base = new URL(url);
+  if (base.hostname === "localhost") base.hostname = "127.0.0.1";
+  try {
+    const res = await fetch(`${base.origin}/api/status?key=${encodeURIComponent(base.searchParams.get("key") ?? "")}`, { signal: AbortSignal.timeout(STATUS_TIMEOUT_MS) });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (typeof json.pid !== "number" || typeof json.clients !== "number" || typeof json.lastActivity !== "number") return null;
+    return { pid: json.pid, clients: json.clients, lastActivity: json.lastActivity };
+  } catch {
+    return null;
+  }
+}
+function serverUrl(root) {
+  try {
+    const { url } = JSON.parse(readText(import_node_path8.default.join(root, ".state", "server-info")) ?? "");
+    return typeof url === "string" ? url : null;
+  } catch {
+    return null;
+  }
+}
+async function listServers(now = Date.now(), platform = process.platform) {
+  const dir = registryDir();
+  const current = process.env.RYUGI_ARTIFACTS_VERSION;
+  const live = readEntries(dir).filter((entry) => {
+    if (hasServerId(entry.pid, entry.serverId)) return true;
+    try {
+      removeEntry(dir, entry);
+    } catch {
+    }
+    return false;
+  });
+  const rows = await Promise.all(live.map(async (entry) => {
+    const url = serverUrl(entry.root);
+    const status = url ? await fetchStatus(url) : null;
+    if (status && status.pid !== entry.pid) return null;
+    if (!status && platform === "win32") return null;
+    const version = readText(import_node_path8.default.join(entry.root, ".state", "server-version")) || null;
+    return {
+      project: entry.project,
+      root: entry.root,
+      pid: entry.pid,
+      url,
+      port: url ? Number(new URL(url).port) : null,
+      startedAt: entry.startedAt,
+      version,
+      oldRelease: !!current && !!version && version !== current,
+      clients: status?.clients ?? null,
+      lastActivity: status?.lastActivity ?? null,
+      safeToStop: safeToStop(status, now),
+      status: status ? "ok" : "no-status",
+      log: import_node_path8.default.join(entry.root, ".state", "server.log")
+    };
+  }));
+  return rows.filter((row) => row !== null).sort((a, b) => a.project.localeCompare(b.project));
+}
+
+// src/cli/stop.ts
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+async function stop(projectDir, emit) {
+  const paths = projectPaths(projectDir);
+  const markStopped = (reason) => {
+    import_node_fs8.default.rmSync(paths.info, { force: true });
+    import_node_fs8.default.mkdirSync(paths.state, { recursive: true });
+    import_node_fs8.default.writeFileSync(paths.stopped, `${JSON.stringify({ reason, timestamp: Math.floor(Date.now() / 1e3) })}
+`);
+  };
+  const pid = Number(readText(paths.pid));
+  if (readText(paths.pid) === null) {
+    emit({ status: "not_running" });
+    return 0;
+  }
+  const id = readText(paths.serverId) ?? "";
+  if (!Number.isInteger(pid) || pid <= 0 || !/^[A-Za-z0-9_-]{32,64}$/.test(id) || !hasServerId(pid, id)) {
+    import_node_fs8.default.rmSync(paths.pid, { force: true });
+    import_node_fs8.default.rmSync(paths.serverId, { force: true });
+    markStopped("stale_pid");
+    emit({ status: "stale_pid" });
+    return 0;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  if (!await waitForExit(pid, 2e3)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+    await waitForExit(pid, 1e3);
+  }
+  if (alive(pid)) {
+    emit({ status: "failed", error: "process still running" });
+    return 1;
+  }
+  for (const file of [paths.pid, paths.serverId, paths.log, paths.owners]) import_node_fs8.default.rmSync(file, { force: true });
+  markStopped("stop");
+  emit({ status: "stopped" });
+  return 0;
+}
+
+// src/cli/monitor-ui.ts
+var LOG_TAIL_BYTES = 64 * 1024;
+var LOG_REFRESH_MS = 500;
+function readTail(file) {
+  let fd;
+  try {
+    fd = import_node_fs9.default.openSync(file, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const size = import_node_fs9.default.fstatSync(fd).size;
+    const length = Math.min(size, LOG_TAIL_BYTES);
+    const buffer = Buffer.alloc(length);
+    import_node_fs9.default.readSync(fd, buffer, 0, length, size - length);
+    return buffer.toString("utf8");
+  } finally {
+    import_node_fs9.default.closeSync(fd);
+  }
+}
+function clipboardCommands() {
+  if (process.platform === "darwin") return [["pbcopy", []]];
+  if (process.platform === "win32") return [["clip", []]];
+  return [["wl-copy", []], ["xclip", ["-selection", "clipboard"]], ["xsel", ["--clipboard", "--input"]]];
+}
+function copy(text2, commands = clipboardCommands()) {
+  const [first, ...rest] = commands;
+  if (!first) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process2.spawn)(first[0], first[1], { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", () => resolve(copy(text2, rest)));
+    child.on("close", (code) => code === 0 ? resolve(true) : resolve(copy(text2, rest)));
+    child.stdin.end(text2);
+  });
+}
+async function runMonitorUi() {
+  const { stdin, stdout } = process;
+  let rows = await listServers();
+  let state = initialView();
+  let busy = false;
+  let closed = false;
+  const restore = () => {
+    if (closed) return;
+    closed = true;
+    try {
+      stdin.setRawMode(false);
+    } catch {
+    }
+    stdout.write("\x1B[?25h\x1B[?1049l");
+  };
+  process.on("exit", restore);
+  const draw = () => {
+    if (closed) return;
+    const screen = { width: stdout.columns || 80, height: stdout.rows || 24, now: Date.now(), home: import_node_os4.default.homedir() };
+    const row = rows[state.selected];
+    const lines = state.mode === "log" && row ? renderLog(row, readTail(row.log), screen) : renderList(rows, state, screen);
+    stdout.write(`\x1B[H${lines.join("\x1B[K\n")}\x1B[K\x1B[J`);
+  };
+  const refresh = async () => {
+    if (busy || closed) return;
+    busy = true;
+    const selected = rows[state.selected]?.project;
+    try {
+      rows = await listServers();
+    } finally {
+      busy = false;
+    }
+    const index = rows.findIndex((row) => row.project === selected);
+    state = { ...state, selected: index >= 0 ? index : Math.min(state.selected, Math.max(0, rows.length - 1)) };
+    if (state.mode === "log" && !rows[state.selected]) state = { ...state, mode: "list" };
+    draw();
+  };
+  const say = (message) => {
+    state = { ...state, message };
+    draw();
+  };
+  const run = async (action) => {
+    if (action.type === "open") {
+      const launcher = browserLauncher(process.platform, action.row.url);
+      if (launcher) (0, import_node_child_process2.execFile)(launcher.bin, launcher.args, () => {
+      });
+      say(launcher ? `Opened ${action.row.url}` : `Open ${action.row.url}`);
+      return;
+    }
+    if (action.type === "copy") {
+      say(await copy(action.row.url) ? `Copied ${action.row.url}` : `No clipboard tool found; the URL is ${action.row.url}`);
+      return;
+    }
+    if (action.type === "stop") {
+      say(`Stopping ${action.rows.length === 1 ? shortPath(action.rows[0].project) : `${action.rows.length} servers`}\u2026`);
+      const failed = [];
+      for (const row of action.rows) {
+        let status = "failed";
+        try {
+          await stop(row.project, (value) => {
+            status = String(value.status ?? "failed");
+          });
+        } catch {
+        }
+        if (status === "failed") failed.push(shortPath(row.project));
+      }
+      await refresh();
+      say(failed.length ? `Could not stop ${failed.join(", ")}` : `Stopped ${action.rows.length === 1 ? shortPath(action.rows[0].project) : `${action.rows.length} servers`}`);
+    }
+  };
+  return new Promise((resolve) => {
+    const timers = [
+      setInterval(() => void refresh(), REFRESH_SECONDS * 1e3),
+      setInterval(() => {
+        if (state.mode === "log") draw();
+      }, LOG_REFRESH_MS)
+    ];
+    const quit = (code) => {
+      timers.forEach(clearInterval);
+      stdin.off("keypress", onKey);
+      stdout.off("resize", draw);
+      stdin.pause();
+      restore();
+      resolve(code);
+    };
+    const onKey = (_, key) => {
+      const result = handleKey(state, key ?? {}, rows);
+      state = result.state;
+      if (result.action?.type === "quit") return quit(0);
+      draw();
+      if (result.action) void run(result.action);
+    };
+    for (const [signal, code] of [["SIGINT", 130], ["SIGTERM", 143], ["SIGHUP", 129]]) process.once(signal, () => quit(code));
+    stdout.write("\x1B[?1049h\x1B[?25l");
+    import_node_readline.default.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("keypress", onKey);
+    stdout.on("resize", draw);
+    draw();
+  });
+}
+
+// src/cli/monitor.ts
+function monitorText(value, now = Date.now()) {
+  if (value.type !== "servers") return null;
+  const rows = value.servers;
+  if (!rows.length) return "No artifacts servers are running.";
+  return rows.map((row) => [
+    shortPath(row.project),
+    row.url ?? "starting",
+    `pid ${row.pid}`,
+    row.clients === null ? null : `tabs ${row.clients}`,
+    row.lastActivity === null ? null : `idle ${duration(now - row.lastActivity)}`,
+    ...tags(row).map((tag) => `[${tag}]`)
+  ].filter(Boolean).join("  ")).join("\n");
+}
+async function monitor(options, emit) {
+  if (options.json || !process.stdout.isTTY || !process.stdin.isTTY) {
+    emit({ type: "servers", servers: await listServers() });
+    return 0;
+  }
+  return runMonitorUi();
+}
+
+// src/cli/start.ts
+var import_node_child_process3 = require("node:child_process");
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_readline2 = __toESM(require("node:readline"), 1);
+
+// src/server/artifact-address.ts
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 
 // src/shared/ids.ts
 var ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
@@ -542,15 +992,15 @@ function artifactKeyOf(relative) {
 
 // src/server/artifact-address.ts
 function artifactId(dir) {
-  const file = import_node_path7.default.join(dir, ".artifact-id");
+  const file = import_node_path9.default.join(dir, ".artifact-id");
   let id;
   try {
-    id = import_node_fs7.default.readFileSync(file, "utf8").trim();
+    id = import_node_fs10.default.readFileSync(file, "utf8").trim();
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    id = import_node_crypto.default.randomBytes(16).toString("hex");
+    id = import_node_crypto2.default.randomBytes(16).toString("hex");
     try {
-      import_node_fs7.default.writeFileSync(file, `${id}
+      import_node_fs10.default.writeFileSync(file, `${id}
 `, { flag: "wx" });
     } catch (writeError) {
       if (writeError.code !== "EEXIST") throw writeError;
@@ -562,8 +1012,8 @@ function artifactId(dir) {
 }
 function artifactPath(root, type, slug) {
   if (!isArtifactType(type) || !isArtifactId(slug)) throw new Error("Invalid artifact locator");
-  const dir = import_node_path7.default.join(root, type, slug);
-  import_node_fs7.default.mkdirSync(dir, { recursive: true });
+  const dir = import_node_path9.default.join(root, type, slug);
+  import_node_fs10.default.mkdirSync(dir, { recursive: true });
   return `/${type}/${artifactId(dir)}`;
 }
 
@@ -601,13 +1051,13 @@ async function withCloudLink(out, artifact) {
 async function acquireLock(lock) {
   for (let attempt = 0; attempt < 150; attempt++) {
     try {
-      import_node_fs8.default.mkdirSync(lock);
+      import_node_fs11.default.mkdirSync(lock);
       return true;
     } catch {
     }
     try {
-      if (Date.now() - import_node_fs8.default.statSync(lock).mtimeMs > 6e4) {
-        import_node_fs8.default.rmdirSync(lock);
+      if (Date.now() - import_node_fs11.default.statSync(lock).mtimeMs > 6e4) {
+        import_node_fs11.default.rmdirSync(lock);
         continue;
       }
     } catch {
@@ -637,13 +1087,13 @@ function registerOwner(paths) {
   const owner = ownerPid();
   if (owner) owners.add(owner);
   const tmp = `${paths.owners}.${process.pid}`;
-  import_node_fs8.default.writeFileSync(tmp, [...owners].sort((a, b) => a - b).map((pid) => `${pid}
+  import_node_fs11.default.writeFileSync(tmp, [...owners].sort((a, b) => a - b).map((pid) => `${pid}
 `).join(""));
-  import_node_fs8.default.renameSync(tmp, paths.owners);
+  import_node_fs11.default.renameSync(tmp, paths.owners);
 }
 function recordAgent(paths) {
   const markers = Object.fromEntries(AGENT_MARKERS.flatMap((key) => process.env[key] ? [[key, process.env[key]]] : []));
-  if (Object.keys(markers).length) import_node_fs8.default.writeFileSync(paths.agent, `${JSON.stringify(markers)}
+  if (Object.keys(markers).length) import_node_fs11.default.writeFileSync(paths.agent, `${JSON.stringify(markers)}
 `);
 }
 async function replace(pid, paths) {
@@ -675,9 +1125,9 @@ async function start(options, emit) {
   const foreground = options.foreground || !options.background && (!!process.env.CODEX_CI || windowsLike());
   process.umask(63);
   const paths = projectPaths(options.projectDir);
-  import_node_fs8.default.mkdirSync(paths.state, { recursive: true });
-  if (!import_node_fs8.default.existsSync(import_node_path8.default.join(paths.state, ".gitignore"))) import_node_fs8.default.writeFileSync(import_node_path8.default.join(paths.state, ".gitignore"), "*\n");
-  const server = import_node_path8.default.join(__dirname, "server.cjs");
+  import_node_fs11.default.mkdirSync(paths.state, { recursive: true });
+  if (!import_node_fs11.default.existsSync(import_node_path10.default.join(paths.state, ".gitignore"))) import_node_fs11.default.writeFileSync(import_node_path10.default.join(paths.state, ".gitignore"), "*\n");
+  const server = import_node_path10.default.join(__dirname, "server.cjs");
   const version = process.env.RYUGI_ARTIFACTS_VERSION ?? "";
   if (!await acquireLock(paths.lock)) throw new CliError("Another start for this project is still starting; retry in a moment");
   let locked = true;
@@ -685,7 +1135,7 @@ async function start(options, emit) {
     if (!locked) return;
     locked = false;
     try {
-      import_node_fs8.default.rmdirSync(paths.lock);
+      import_node_fs11.default.rmdirSync(paths.lock);
     } catch {
     }
   };
@@ -703,20 +1153,20 @@ async function start(options, emit) {
     }
     registerOwner(paths);
     recordAgent(paths);
-    import_node_fs8.default.rmSync(paths.info, { force: true });
-    const id = import_node_crypto2.default.randomBytes(24).toString("hex");
-    import_node_fs8.default.writeFileSync(paths.serverId, `${id}
+    import_node_fs11.default.rmSync(paths.info, { force: true });
+    const id = import_node_crypto3.default.randomBytes(24).toString("hex");
+    import_node_fs11.default.writeFileSync(paths.serverId, `${id}
 `);
-    import_node_fs8.default.writeFileSync(paths.version, `${version}
+    import_node_fs11.default.writeFileSync(paths.version, `${version}
 `);
     const env = serverEnv(paths, options);
     const args = [server, `--artifacts-server-id=${id}`];
     if (foreground) {
-      const child2 = (0, import_node_child_process2.spawn)(process.execPath, args, { env, stdio: ["ignore", "pipe", "inherit"] });
-      import_node_fs8.default.writeFileSync(paths.pid, `${child2.pid}
+      const child2 = (0, import_node_child_process3.spawn)(process.execPath, args, { env, stdio: ["ignore", "pipe", "inherit"] });
+      import_node_fs11.default.writeFileSync(paths.pid, `${child2.pid}
 `);
       for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => child2.kill("SIGTERM"));
-      import_node_readline.default.createInterface({ input: child2.stdout }).on("line", (line) => {
+      import_node_readline2.default.createInterface({ input: child2.stdout }).on("line", (line) => {
         let value;
         try {
           value = JSON.parse(line);
@@ -729,15 +1179,15 @@ async function start(options, emit) {
         else void withCloudLink(withLink(value, options.artifact, false), options.artifact).then(emit);
       });
       const exited = new Promise((resolve) => child2.on("close", (code) => resolve(code ?? 1)));
-      for (let waited = 0; waited < 5e3 && !import_node_fs8.default.existsSync(paths.info); waited += 100) await sleep(100);
+      for (let waited = 0; waited < 5e3 && !import_node_fs11.default.existsSync(paths.info); waited += 100) await sleep(100);
       unlock();
       return await exited;
     }
-    const log = import_node_fs8.default.openSync(paths.log, "w");
-    const child = (0, import_node_child_process2.spawn)(process.execPath, args, { env, detached: true, stdio: ["ignore", log, log] });
-    import_node_fs8.default.closeSync(log);
+    const log = import_node_fs11.default.openSync(paths.log, "w");
+    const child = (0, import_node_child_process3.spawn)(process.execPath, args, { env, detached: true, stdio: ["ignore", log, log] });
+    import_node_fs11.default.closeSync(log);
     child.unref();
-    import_node_fs8.default.writeFileSync(paths.pid, `${child.pid}
+    import_node_fs11.default.writeFileSync(paths.pid, `${child.pid}
 `);
     for (let waited = 0; waited < 5e3; waited += 100) {
       const lines = (readText(paths.log) ?? "").split("\n");
@@ -816,52 +1266,8 @@ async function publish(options, emit) {
   return 0;
 }
 
-// src/cli/stop.ts
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-async function stop(projectDir, emit) {
-  const paths = projectPaths(projectDir);
-  const markStopped = (reason) => {
-    import_node_fs9.default.rmSync(paths.info, { force: true });
-    import_node_fs9.default.mkdirSync(paths.state, { recursive: true });
-    import_node_fs9.default.writeFileSync(paths.stopped, `${JSON.stringify({ reason, timestamp: Math.floor(Date.now() / 1e3) })}
-`);
-  };
-  const pid = Number(readText(paths.pid));
-  if (readText(paths.pid) === null) {
-    emit({ status: "not_running" });
-    return 0;
-  }
-  const id = readText(paths.serverId) ?? "";
-  if (!Number.isInteger(pid) || pid <= 0 || !/^[A-Za-z0-9_-]{32,64}$/.test(id) || !hasServerId(pid, id)) {
-    import_node_fs9.default.rmSync(paths.pid, { force: true });
-    import_node_fs9.default.rmSync(paths.serverId, { force: true });
-    markStopped("stale_pid");
-    emit({ status: "stale_pid" });
-    return 0;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-  }
-  if (!await waitForExit(pid, 2e3)) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-    await waitForExit(pid, 1e3);
-  }
-  if (alive(pid)) {
-    emit({ status: "failed", error: "process still running" });
-    return 1;
-  }
-  for (const file of [paths.pid, paths.serverId, paths.log, paths.owners]) import_node_fs9.default.rmSync(file, { force: true });
-  markStopped("stop");
-  emit({ status: "stopped" });
-  return 0;
-}
-
 // src/cli/main.ts
-var HELP = `Usage: ryugi-artifacts [project-directory] [--no-open]
+var HELP2 = `Usage: ryugi-artifacts [project-directory] [--no-open]
        ryugi-artifacts <command> [options]
 
 Without a command, opens the project's artifacts in your browser and keeps the server
@@ -882,6 +1288,8 @@ Commands:
               reply   --artifact <document|artboard>/<id> --thread <threadId> [--text <text>]
               resolve --artifact <document|artboard>/<id> --thread <threadId>
             Without --text, add and reply read the message from stdin.
+  monitor   List every running artifacts server on this machine and manage them. In a terminal it
+            opens a live view (open, copy URL, logs, stop); otherwise, or with --json, prints the list once.
   config    Auto-publish changed artifacts as private cloud copies when the agent's turn ends:
               --auto-publish on|off              for every project
               --auto-publish on|off|inherit --project   override for this project only
@@ -914,6 +1322,8 @@ ${value.url}`;
   if (value.type === "auto-publish") return `Auto-publish: ${value.global === null ? "not decided" : value.global ? "on" : "off"} for every project${value.project === null ? "" : `, ${value.project ? "on" : "off"} for this project`}.`;
   const checked = checkText(value);
   if (checked !== null) return checked;
+  const servers = monitorText(value);
+  if (servers !== null) return servers;
   const commented = commentText(value);
   if (commented !== null) return commented;
   if (typeof value.status === "string") return value.status === "stopped" ? "Stopped." : value.status.replace(/_/g, " ");
@@ -922,7 +1332,7 @@ ${value.url}`;
 function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", '""', url] : [url];
-  (0, import_node_child_process3.execFile)(command, args, () => {
+  (0, import_node_child_process4.execFile)(command, args, () => {
   });
 }
 async function browse(argv) {
@@ -1045,12 +1455,16 @@ async function main(argv) {
         project: !!values.project
       }, emit);
     }
+    if (command === "monitor") {
+      const { values } = parse(rest, {});
+      return await monitor({ json: !!values.json }, emit);
+    }
     if (command === "--version" || command === "-v") {
-      console.log("1.32.0");
+      console.log("1.33.0");
       return 0;
     }
     if (command === "--help" || command === "-h") {
-      console.log(HELP);
+      console.log(HELP2);
       return 0;
     }
     return await browse(argv);