ryugi-artifacts 1.43.0 → 1.44.0

package/dist/cli.cjs

@@ -1563,59 +1563,15 @@ var require_canvas = __commonJS({
 });
 
 // src/cli/main.ts
-var import_node_child_process5 = require("node:child_process");
-var import_node_os6 = __toESM(require("node:os"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
-var import_node_util2 = require("node:util");
-
-// src/server/credentials.ts
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
-
-// src/server/state.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-
-// src/shared/types.ts
-var ARTIFACT_TYPES = ["artboard", "document", "html"];
-
-// src/shared/validate.ts
-var BOARD_NUMBERS = ["x", "y", "w", "h"];
-var BOARD_REQUIRED = ["file", "page", ...BOARD_NUMBERS];
-var MEDIA_REQUIRED = ["src", "page", ...BOARD_NUMBERS];
+var import_node_child_process7 = require("node:child_process");
 
-// src/server/state.ts
-function writeJsonAtomic(file, value) {
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384 });
-  import_node_fs.default.renameSync(tmp, file);
-}
-
-// src/server/credentials.ts
-function credentialsFile(env, platform, home) {
-  if (platform === "win32" && env.APPDATA) return import_node_path2.default.join(env.APPDATA, "ryugi", "credentials.json");
-  return import_node_path2.default.join(env.XDG_CONFIG_HOME || import_node_path2.default.join(home, ".config"), "ryugi", "credentials.json");
-}
-function readCredentials(file, origin) {
-  let raw;
-  try {
-    raw = JSON.parse(import_node_fs2.default.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-  if (typeof raw !== "object" || raw === null) return null;
-  const { origin: savedOrigin, token, login } = raw;
-  if (typeof savedOrigin !== "string" || typeof token !== "string" || typeof login !== "string") return null;
-  if (savedOrigin !== origin) return null;
-  return { origin: savedOrigin, token, login };
-}
+// src/cli/command.ts
+var import_node_util = require("node:util");
 
 // src/cli/paths.ts
-var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
 var CliError = class extends Error {
   constructor(message, fields = {}, code = 1) {
     super(message);
@@ -1629,50 +1585,120 @@ var resolvesRoot = () => !process.env.RYUGI_ARTIFACTS_COMMAND || process.env.RYU
 function projectRoot(dir) {
   let home = "";
   try {
-    home = import_node_fs3.default.realpathSync(import_node_os.default.homedir());
+    home = import_node_fs.default.realpathSync(import_node_os.default.homedir());
   } catch {
   }
   const chain = [];
-  for (let current = dir; ; current = import_node_path3.default.dirname(current)) {
+  for (let current = dir; ; current = import_node_path.default.dirname(current)) {
     chain.push(current);
-    if (import_node_fs3.default.existsSync(import_node_path3.default.join(current, ".git")) && (current !== home || dir === home)) break;
-    if (import_node_path3.default.dirname(current) === current) return dir;
+    if (import_node_fs.default.existsSync(import_node_path.default.join(current, ".git")) && (current !== home || dir === home)) break;
+    if (import_node_path.default.dirname(current) === current) return dir;
   }
-  return chain.find((candidate) => import_node_fs3.default.existsSync(import_node_path3.default.join(candidate, ".ryugi", "artifacts"))) ?? chain[chain.length - 1];
+  return chain.find((candidate) => import_node_fs.default.existsSync(import_node_path.default.join(candidate, ".ryugi", "artifacts"))) ?? chain[chain.length - 1];
 }
 function projectPaths(dir) {
   let project;
   try {
-    project = import_node_fs3.default.realpathSync(import_node_path3.default.resolve(dir));
-    if (!import_node_fs3.default.statSync(project).isDirectory()) throw new Error();
+    project = import_node_fs.default.realpathSync(import_node_path.default.resolve(dir));
+    if (!import_node_fs.default.statSync(project).isDirectory()) throw new Error();
   } catch {
     throw new CliError(`Project directory not found: ${dir}`);
   }
   if (resolvesRoot()) project = projectRoot(project);
-  const root = import_node_path3.default.join(project, ".ryugi", "artifacts");
-  const state = import_node_path3.default.join(root, ".state");
+  const root = import_node_path.default.join(project, ".ryugi", "artifacts");
+  const state = import_node_path.default.join(root, ".state");
   return {
     project,
     root,
     state,
-    pid: import_node_path3.default.join(state, "server.pid"),
-    log: import_node_path3.default.join(state, "server.log"),
-    serverId: import_node_path3.default.join(state, "server-instance-id"),
-    info: import_node_path3.default.join(state, "server-info"),
-    version: import_node_path3.default.join(state, "server-version"),
-    owners: import_node_path3.default.join(state, "owners"),
-    agent: import_node_path3.default.join(state, "agent"),
-    stopped: import_node_path3.default.join(state, "server-stopped"),
-    lock: import_node_path3.default.join(state, "start.lock")
+    pid: import_node_path.default.join(state, "server.pid"),
+    log: import_node_path.default.join(state, "server.log"),
+    serverId: import_node_path.default.join(state, "server-instance-id"),
+    info: import_node_path.default.join(state, "server-info"),
+    version: import_node_path.default.join(state, "server-version"),
+    owners: import_node_path.default.join(state, "owners"),
+    agent: import_node_path.default.join(state, "agent"),
+    stopped: import_node_path.default.join(state, "server-stopped"),
+    lock: import_node_path.default.join(state, "start.lock")
   };
 }
 var invocation = () => process.env.RYUGI_ARTIFACTS_COMMAND || "ryugi-artifacts";
 var ARTIFACT_PATTERN = /^(artboard|document|html)\/[a-z0-9][a-z0-9-]*$/;
 var ARTIFACT_ERROR = "--artifact must be <type>/<id>: type artboard, document or html, id of lowercase letters, digits and hyphens";
 
+// src/cli/command.ts
+var BIN = "ryugi-artifacts";
+var COMMON = {
+  "project-dir": { type: "string", value: "<path>", help: "Project directory (default: current directory)" },
+  json: { type: "boolean", help: "Print one JSON line (default when not in a terminal)" }
+};
+var HELP_OPTION = { help: { type: "boolean", short: "h", help: "Show this help" } };
+function parse(args, options, positionals = 0) {
+  const config2 = Object.fromEntries(Object.entries({ ...COMMON, ...options }).map(([name, { type, short }]) => [name, short ? { type, short } : { type }]));
+  try {
+    const parsed = (0, import_node_util.parseArgs)({ args, options: config2, allowPositionals: positionals > 0, strict: true });
+    if (parsed.positionals.length > positionals) throw new CliError(`Unknown argument: ${parsed.positionals[positionals]}`);
+    return {
+      values: parsed.values,
+      positionals: parsed.positionals,
+      projectDir: parsed.values["project-dir"] ?? process.cwd()
+    };
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    const flag = /'([^']+)'/.exec(err.message)?.[1];
+    throw new CliError(flag ? `Unknown argument: ${flag.split(" ")[0]}` : err.message);
+  }
+}
+function wantsHelp(args) {
+  const end = args.indexOf("--");
+  return (end === -1 ? args : args.slice(0, end)).some((arg) => arg === "--help" || arg === "-h");
+}
+function table(rows) {
+  const width = Math.max(...rows.map(([left]) => left.length)) + 2;
+  return rows.map(([left, right]) => `  ${left.padEnd(width)}${right.replace(/\n/g, `
+  ${" ".repeat(width)}`)}`.trimEnd()).join("\n");
+}
+function optionRows(options) {
+  return Object.entries(options).filter(([, option]) => option.help !== void 0).map(([name, option]) => [`${option.short ? `-${option.short}, ` : ""}--${name}${option.value ? ` ${option.value}` : ""}`, option.help]);
+}
+function commandHelp(command) {
+  const usage = (command.usage ?? ["[options]"]).map((line, index) => `${index ? "       " : "Usage: "}${BIN} ${command.name} ${line}`);
+  return [
+    usage.join("\n"),
+    "",
+    command.summary,
+    ...command.details ? ["", command.details] : [],
+    "",
+    "Options:",
+    table(optionRows({ ...command.options, ...COMMON, ...HELP_OPTION }))
+  ].join("\n");
+}
+function rootHelp(commands, browseOptions = {}) {
+  return [
+    `Usage: ${BIN} [project-directory] [--no-open]`,
+    `       ${BIN} <command> [options]`,
+    "",
+    "Without a command, opens the project's artifacts in your browser and keeps the server",
+    "running until Ctrl+C.",
+    "",
+    "Commands:",
+    table(commands.map((command) => [command.name, command.summary])),
+    "",
+    `Run \`${BIN} <command> --help\` for a command's options.`,
+    "",
+    "Options:",
+    table(optionRows({
+      ...COMMON,
+      ...browseOptions,
+      version: { type: "boolean", short: "v", help: "Print the version" },
+      ...HELP_OPTION
+    }))
+  ].join("\n");
+}
+
 // src/cli/process.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function alive(pid) {
   try {
@@ -1684,7 +1710,7 @@ function alive(pid) {
 }
 function commandLine(pid) {
   try {
-    return import_node_fs4.default.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0");
+    return import_node_fs2.default.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0");
   } catch {
   }
   const direct = (0, import_node_child_process.spawnSync)("ps", ["-ww", "-p", String(pid), "-o", "command="], { encoding: "utf8" });
@@ -1716,7 +1742,7 @@ async function waitForExit(pid, ms) {
 }
 var readText = (file) => {
   try {
-    return import_node_fs4.default.readFileSync(file, "utf8").replace(/[\r\n]+$/, "");
+    return import_node_fs2.default.readFileSync(file, "utf8").replace(/[\r\n]+$/, "");
   } catch {
     return null;
   }
@@ -1781,9 +1807,19 @@ function checkText(value) {
   return lines.length ? `${value.artifact}
 ${lines.join("\n")}` : `${value.artifact}: no warnings`;
 }
+var checkCommand = {
+  name: "check",
+  summary: "Wait until the server has checked the latest write, then print its warnings (needs a running server)",
+  usage: ["--artifact <type>/<id> [options]"],
+  options: {
+    artifact: { type: "string", value: "<type>/<id>", help: "The artifact to check" }
+  },
+  run: ({ values, projectDir }, emit) => check({ projectDir, artifact: values.artifact }, emit),
+  text: checkText
+};
 
 // src/cli/comment.ts
-var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs3 = __toESM(require("node:fs"), 1);
 
 // src/server/agent.ts
 var NAMES = {
@@ -1877,7 +1913,7 @@ var WRITTEN = { add: "comment-added", reply: "comment-replied", resolve: "commen
 function readStdin() {
   if (process.stdin.isTTY) return "";
   try {
-    return import_node_fs5.default.readFileSync(0, "utf8");
+    return import_node_fs3.default.readFileSync(0, "utf8");
   } catch {
     return "";
   }
@@ -1970,18 +2006,77 @@ ${groups.map(groupText).join("\n")}` : head;
   if (value.type === "comment-resolved") return `Resolved thread ${value.threadId}`;
   return null;
 }
+var commentCommand = {
+  name: "comment",
+  summary: "Read and answer comments on a document or artboard (needs a running server)",
+  usage: [
+    "list    --artifact <document|artboard>/<id> [--all]",
+    "add     --artifact document/<id> --block <blockId> [--quote <text>] [--text <text>]",
+    "add     --artifact artboard/<id> --board <boardId> [--x <px> --y <px>] [--text <text>]",
+    "reply   --artifact <document|artboard>/<id> --thread <threadId> [--text <text>]",
+    "resolve --artifact <document|artboard>/<id> --thread <threadId>"
+  ],
+  details: "list prints what changed since you last listed. Without --text, add and reply read the message from stdin.",
+  options: {
+    artifact: { type: "string", value: "<type>/<id>", help: "The document or artboard" },
+    all: { type: "boolean", help: "list: every thread, not only what changed" },
+    block: { type: "string", value: "<blockId>", help: "add: the document block to comment on" },
+    quote: { type: "string", value: "<text>", help: "add: the text in the block the comment is about" },
+    board: { type: "string", value: "<boardId>", help: "add: the artboard board to comment on" },
+    x: { type: "string", value: "<px>", help: "add: horizontal position on the board" },
+    y: { type: "string", value: "<px>", help: "add: vertical position on the board" },
+    thread: { type: "string", value: "<threadId>", help: "reply, resolve: the thread" },
+    text: { type: "string", value: "<text>", help: "add, reply: the message" }
+  },
+  positionals: 1,
+  run: ({ values, positionals, projectDir }, emit) => comment({
+    projectDir,
+    action: positionals[0],
+    artifact: values.artifact,
+    all: values.all,
+    block: values.block,
+    quote: values.quote,
+    thread: values.thread,
+    text: values.text,
+    board: values.board,
+    x: values.x,
+    y: values.y
+  }, emit),
+  text: commentText
+};
 
 // src/cli/config.ts
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
 
 // src/server/config.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 
 // src/shared/cloud.ts
 var isVisibility = (value) => value === "private" || value === "public";
 
+// src/server/state.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+
+// src/shared/types.ts
+var ARTIFACT_TYPES = ["artboard", "document", "html"];
+
+// src/shared/validate.ts
+var BOARD_NUMBERS = ["x", "y", "w", "h"];
+var BOARD_REQUIRED = ["file", "page", ...BOARD_NUMBERS];
+var MEDIA_REQUIRED = ["src", "page", ...BOARD_NUMBERS];
+
+// src/server/state.ts
+function writeJsonAtomic(file, value) {
+  import_node_fs4.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  import_node_fs4.default.renameSync(tmp, file);
+}
+
 // src/server/config.ts
 var defaults = () => ({ version: 1, artifacts: {} });
 function isCloudRecord(value) {
@@ -2014,7 +2109,7 @@ function normalize(raw) {
 function readConfig(file) {
   let text2;
   try {
-    text2 = import_node_fs6.default.readFileSync(file, "utf8");
+    text2 = import_node_fs5.default.readFileSync(file, "utf8");
   } catch {
     return { config: defaults() };
   }
@@ -2026,32 +2121,53 @@ function readConfig(file) {
 }
 var IGNORED = ["config.json", "artifacts/*", "!artifacts/document/", "artifacts/document/*/.artifact-id"];
 function ensureGitignore(dir) {
-  const file = import_node_path4.default.join(dir, ".gitignore");
+  const file = import_node_path3.default.join(dir, ".gitignore");
   let current = "";
   try {
-    current = import_node_fs6.default.readFileSync(file, "utf8");
+    current = import_node_fs5.default.readFileSync(file, "utf8");
   } catch {
   }
   const present = new Set(current.split(/\r?\n/).map((line) => line.trim()));
   const missing = IGNORED.filter((line) => !present.has(line));
   if (missing.length === 0) return;
-  import_node_fs6.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}${missing.join("\n")}
+  import_node_fs5.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}${missing.join("\n")}
 `);
 }
 function ensureConfig(file) {
-  import_node_fs6.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-  ensureGitignore(import_node_path4.default.dirname(file));
-  if (!import_node_fs6.default.existsSync(file)) writeJsonAtomic(file, defaults());
+  import_node_fs5.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  ensureGitignore(import_node_path3.default.dirname(file));
+  if (!import_node_fs5.default.existsSync(file)) writeJsonAtomic(file, defaults());
 }
 function setProjectAutoPublish(file, value) {
   const { config: config2, warning } = readConfig(file);
   if (warning) throw new Error(warning);
   if (value === null) delete config2.autoPublish;
   else config2.autoPublish = value;
-  import_node_fs6.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
   writeJsonAtomic(file, config2);
 }
 
+// src/server/credentials.ts
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+function credentialsFile(env, platform, home) {
+  if (platform === "win32" && env.APPDATA) return import_node_path4.default.join(env.APPDATA, "ryugi", "credentials.json");
+  return import_node_path4.default.join(env.XDG_CONFIG_HOME || import_node_path4.default.join(home, ".config"), "ryugi", "credentials.json");
+}
+function readCredentials(file, origin) {
+  let raw;
+  try {
+    raw = JSON.parse(import_node_fs6.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const { origin: savedOrigin, token, login } = raw;
+  if (typeof savedOrigin !== "string" || typeof token !== "string" || typeof login !== "string") return null;
+  if (savedOrigin !== origin) return null;
+  return { origin: savedOrigin, token, login };
+}
+
 // src/server/settings.ts
 var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
@@ -2090,9 +2206,26 @@ function config(options, emit) {
   emit({ type: "auto-publish", global: readGlobalAutoPublish(globalFile) ?? null, project: readConfig(projectFile).config.autoPublish ?? null });
   return 0;
 }
+var configCommand = {
+  name: "config",
+  summary: "Auto-publish changed artifacts as private cloud copies when the agent's turn ends",
+  usage: ["[--auto-publish on|off] [options]", "--auto-publish on|off|inherit --project [options]"],
+  details: "Without --auto-publish, prints the current values.",
+  options: {
+    "auto-publish": { type: "string", value: "on|off|inherit", help: "Turn auto-publish on or off; inherit (with --project) drops the override" },
+    project: { type: "boolean", help: "Set it for this project only instead of every project" }
+  },
+  run: ({ values, projectDir }, emit) => config({
+    projectDir,
+    autoPublish: values["auto-publish"],
+    project: !!values.project
+  }, emit),
+  text: (value) => value.type === "auto-publish" ? `Auto-publish: ${value.global === null ? "not decided" : value.global ? "on" : "off"} for every project${value.project === null ? "" : `, ${value.project ? "on" : "off"} for this project`}.` : null
+};
 
 // src/cli/get.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 
 // node_modules/.pnpm/nanoid@6.0.2/node_modules/nanoid/url-alphabet/index.js
@@ -2163,14 +2296,14 @@ function customAlphabet(alphabet, defaultSize = 21) {
   });
   let alphabetLen = alphabet.length;
   let mask = (2 << 31 - Math.clz32(alphabetLen - 1 | 1)) - 1;
-  let pool = "";
-  let poolOffset = 0;
+  let pool2 = "";
+  let poolOffset2 = 0;
   let poolNext = 0;
   return (size = defaultSize) => {
     size |= 0;
     if (size < 0) throw new RangeError("Wrong ID size");
     if (size === 0) return "";
-    if (poolOffset + size > pool.length) {
+    if (poolOffset2 + size > pool2.length) {
       let target = Math.max(poolNext, size);
       poolNext = Math.min(target * 16, POOL_MAX);
       let buffer = Buffer.allocUnsafe(target);
@@ -2195,11 +2328,11 @@ function customAlphabet(alphabet, defaultSize = 21) {
           }
         }
       }
-      pool = buffer.toString("latin1");
-      poolOffset = 0;
+      pool2 = buffer.toString("latin1");
+      poolOffset2 = 0;
     }
-    poolOffset += size;
-    return pool.substring(poolOffset - size, poolOffset);
+    poolOffset2 += size;
+    return pool2.substring(poolOffset2 - size, poolOffset2);
   };
 }
 var nanoid = customAlphabet(urlAlphabet);
@@ -3509,11 +3642,11 @@ function isTextRun(node) {
 }
 function serializeTextRun(run) {
   if (run.length === 1) return wrapWithFormatTags(run[0].text, run[0].format);
-  const common2 = run.reduce((acc, node) => acc & node.format, -1);
-  if (common2 !== 0) return wrapContentWithFormatTags(serializeTextRun(run.map((node) => ({
+  const common = run.reduce((acc, node) => acc & node.format, -1);
+  if (common !== 0) return wrapContentWithFormatTags(serializeTextRun(run.map((node) => ({
     ...node,
-    format: node.format & ~common2
-  }))), common2);
+    format: node.format & ~common
+  }))), common);
   const groups = [];
   let current;
   let previous;
@@ -8380,7 +8513,7 @@ function isQuote(c) {
 function isWhitespace2(c) {
   return c === CharCode.Space || c === CharCode.Tab || c === CharCode.NewLine || c === CharCode.FormFeed || c === CharCode.CarriageReturn;
 }
-function parse(selector) {
+function parse2(selector) {
   const subselects2 = [];
   const endIndex = parseSelector(subselects2, `${selector}`, 0);
   if (endIndex < selector.length) {
@@ -9788,7 +9921,7 @@ function compile(parsed) {
 var whitespace = /* @__PURE__ */ new Set([9, 10, 12, 13, 32]);
 var ZERO = "0".charCodeAt(0);
 var NINE = "9".charCodeAt(0);
-function parse2(formula) {
+function parse3(formula) {
   formula = formula.trim().toLowerCase();
   switch (formula) {
     case "even": {
@@ -9849,7 +9982,7 @@ function parse2(formula) {
 
 // node_modules/.pnpm/nth-check@3.0.1/node_modules/nth-check/dist/index.js
 function nthCheck(formula) {
-  return compile(parse2(formula));
+  return compile(parse3(formula));
 }
 
 // node_modules/.pnpm/css-select@7.0.0/node_modules/css-select/dist/helpers/cache.js
@@ -9914,7 +10047,7 @@ function compileNth(reverse, ofType) {
     const nthCheck2 = nthCheck(ofMatch ? ofMatch[1].trim() : rule);
     if (nthCheck2 === falseFunc)
       return falseFunc;
-    const ofSelector = ofMatch && compileToken2 ? compileToken2(parse(ofMatch[2].trim()), copyOptions(options), context) : void 0;
+    const ofSelector = ofMatch && compileToken2 ? compileToken2(parse2(ofMatch[2].trim()), copyOptions(options), context) : void 0;
     if (ofSelector === falseFunc)
       return falseFunc;
     if (nthCheck2 === trueFunc && !ofSelector) {
@@ -10245,7 +10378,7 @@ function compilePseudoSelector(next, selector, options, context, compileToken2)
     if (data != null) {
       throw new Error(`Pseudo ${name} doesn't have any arguments`);
     }
-    const alias = parse(stringPseudo);
+    const alias = parse2(stringPseudo);
     return subselects["is"](next, alias, options, context, compileToken2);
   }
   if (typeof userPseudo === "function") {
@@ -10489,7 +10622,7 @@ function compile2(selector, options, context) {
   return next === falseFunc ? falseFunc : (element) => convertedOptions.adapter.isTag(element) && next(element);
 }
 function _compileUnsafe(selector, options, context) {
-  return compileToken(typeof selector === "string" ? parse(selector) : selector, convertOptionFormats(options), context);
+  return compileToken(typeof selector === "string" ? parse2(selector) : selector, convertOptionFormats(options), context);
 }
 function getSelectorFunction(searchFunction) {
   return function select(query2, elements, options) {
@@ -14137,7 +14270,7 @@ var DOMParser = class _DOMParser {
 };
 
 // node_modules/.pnpm/linkedom@0.18.13/node_modules/linkedom/esm/shared/parse-json.js
-var { parse: parse4 } = JSON;
+var { parse: parse5 } = JSON;
 
 // node_modules/.pnpm/linkedom@0.18.13/node_modules/linkedom/esm/index.js
 var parseHTML = (html, globals = null) => new DOMParser().parseFromString(
@@ -14153,6 +14286,69 @@ setPrototypeOf(Document4, Document2).prototype = Document2.prototype;
 // node_modules/.pnpm/@haklex+rich-litexml@0.58.0_typescript@5.9.3/node_modules/@haklex/rich-litexml/dist/node.mjs
 registerParseHTML((html) => parseHTML(html).document);
 
+// node_modules/.pnpm/nanoid@5.1.16/node_modules/nanoid/index.js
+var import_node_crypto = require("node:crypto");
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (bytes < 0) throw new RangeError("Wrong ID size");
+  try {
+    if (!pool || pool.length < bytes) {
+      pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+      import_node_crypto.webcrypto.getRandomValues(pool);
+      poolOffset = 0;
+    } else if (poolOffset + bytes > pool.length) {
+      import_node_crypto.webcrypto.getRandomValues(pool);
+      poolOffset = 0;
+    }
+  } catch (e) {
+    pool = void 0;
+    throw e;
+  }
+  poolOffset += bytes;
+}
+function random2(bytes) {
+  fillPool(bytes |= 0);
+  return pool.subarray(poolOffset - bytes, poolOffset);
+}
+function customRandom2(alphabet, defaultSize, getRandom) {
+  let safeByteCutoff = 256 - 256 % alphabet.length;
+  if (safeByteCutoff === 256) {
+    let mask = alphabet.length - 1;
+    return (size = defaultSize) => {
+      if (!size) return "";
+      let id = "";
+      while (true) {
+        let bytes = getRandom(size);
+        let i = size;
+        while (i--) {
+          id += alphabet[bytes[i] & mask];
+          if (id.length >= size) return id;
+        }
+      }
+    };
+  }
+  let step = Math.ceil(1.6 * 256 * defaultSize / safeByteCutoff);
+  return (size = defaultSize) => {
+    if (!size) return "";
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        if (bytes[i] < safeByteCutoff) {
+          id += alphabet[bytes[i] % alphabet.length];
+          if (id.length >= size) return id;
+        }
+      }
+    }
+  };
+}
+function customAlphabet2(alphabet, size = 21) {
+  return customRandom2(alphabet, size, random2);
+}
+
 // src/server/document-codec.ts
 var BLOCK_TAGS = [
   "doc",
@@ -14323,9 +14519,44 @@ ${threads.join("\n\n")}
 `);
   return parts.join("");
 }
+var getCommand = {
+  name: "get",
+  summary: "Read a published Ryugi Cloud artifact by link or id, signed in as this machine's cloud account",
+  usage: ["<link-or-id> [--out <dir>] [--no-comments] [options]"],
+  details: "Prints the source (a document's LiteXML and comments) unless --json; artboard and HTML files, and files a document uses, are downloaded to --out or ~/.cache/ryugi/get/<id>/.",
+  options: {
+    out: { type: "string", value: "<dir>", help: "Download files here instead of ~/.cache/ryugi/get/<id>/" },
+    "no-comments": { type: "boolean", help: "Leave a document's comments out" }
+  },
+  positionals: 1,
+  // Agents run commands without a TTY and the signpost's command has no --json, so get prints the source unless --json is explicit.
+  explicitJson: true,
+  run: async ({ values, positionals }) => {
+    const json = !!values.json;
+    try {
+      if (!positionals[0]) throw new CliError("Give a Ryugi Cloud link or artifact id.");
+      const result = await getArtifact({
+        target: positionals[0],
+        defaultOrigin: (process.env.RYUGI_CLOUD_ORIGIN || "https://ryugi.innei.dev").replace(/\/+$/, ""),
+        credentialsFile: credentialsFile(process.env, process.platform, import_node_os3.default.homedir()),
+        cacheRoot: import_node_path7.default.join(process.env.XDG_CACHE_HOME || import_node_path7.default.join(import_node_os3.default.homedir(), ".cache"), "ryugi", "get"),
+        out: values.out
+      });
+      if (json) console.log(JSON.stringify(result));
+      else process.stdout.write(getText4(result, { comments: !values["no-comments"] }));
+      return 0;
+    } catch (caught) {
+      const err = caught instanceof CliError ? caught : new CliError(caught.message);
+      const fields = err.message ? { error: err.message, ...err.fields } : err.fields;
+      if (json) console.log(JSON.stringify(fields));
+      else console.error(err.message ? `Error: ${err.message}` : String(err.fields.message));
+      return err.code;
+    }
+  }
+};
 
 // src/cli/monitor-view.ts
-var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
 var REFRESH_SECONDS = 2;
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
@@ -14342,7 +14573,7 @@ function duration(ms) {
   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_os3.default.homedir()) => project === home || project.startsWith(`${home}/`) ? `~${project.slice(home.length)}` : project;
+var shortPath = (project, home = import_node_os4.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);
 }
@@ -14449,7 +14680,7 @@ function handleKey(state, key2, rows) {
 // src/cli/monitor-ui.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // src/server/lifecycle.ts
@@ -14466,16 +14697,16 @@ function browserLauncher(platform, url) {
 var import_node_path9 = __toESM(require("node:path"), 1);
 
 // src/server/registry.ts
-var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_path8 = __toESM(require("node:path"), 1);
-function registryDir(env = process.env, platform = process.platform, uid = process.getuid?.() ?? -1, tmpdir = import_node_os4.default.tmpdir()) {
+function registryDir(env = process.env, platform = process.platform, uid = process.getuid?.() ?? -1, tmpdir = import_node_os5.default.tmpdir()) {
   if (env.RYUGI_RUNTIME_DIR) return import_node_path8.default.join(env.RYUGI_RUNTIME_DIR, "servers");
   if (platform === "win32") return import_node_path8.default.join(tmpdir, "ryugi", "servers");
   return `/tmp/ryugi-${uid}/servers`;
 }
-var fileFor = (dir, project) => import_node_path8.default.join(dir, `${import_node_crypto.default.createHash("sha256").update(project).digest("hex").slice(0, 16)}.json`);
+var fileFor = (dir, project) => import_node_path8.default.join(dir, `${import_node_crypto2.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_path8.default.dirname(dir), dir]) {
@@ -14613,6 +14844,14 @@ async function stop(projectDir, emit) {
   emit({ status: "stopped" });
   return 0;
 }
+var stopCommand = {
+  name: "stop",
+  summary: "Stop the project's artifacts server; the artifacts are kept",
+  usage: ["[project-directory] [options]"],
+  options: {},
+  positionals: 1,
+  run: ({ values, positionals }, emit) => stop(values["project-dir"] ?? positionals[0] ?? process.cwd(), emit)
+};
 
 // src/cli/monitor-ui.ts
 var LOG_TAIL_BYTES = 64 * 1024;
@@ -14667,7 +14906,7 @@ async function runMonitorUi() {
   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_os5.default.homedir() };
+    const screen = { width: stdout.columns || 80, height: stdout.rows || 24, now: Date.now(), home: import_node_os6.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`);
@@ -14773,6 +15012,85 @@ async function monitor(options, emit) {
   }
   return runMonitorUi();
 }
+var monitorCommand = {
+  name: "monitor",
+  summary: "List every running artifacts server on this machine and manage them",
+  details: "In a terminal it opens a live view (open, copy URL, logs, stop); otherwise, or with --json, prints the list once.",
+  options: {},
+  run: ({ values }, emit) => monitor({ json: !!values.json }, emit),
+  text: (value) => monitorText(value)
+};
+
+// src/cli/publish.ts
+async function publish(options, emit) {
+  if (options.action === "publish" || options.action === "unpublish") {
+    if (!options.artifact) throw new CliError("--artifact <type>/<id> is required");
+    if (!ARTIFACT_PATTERN.test(options.artifact)) throw new CliError(ARTIFACT_ERROR);
+  }
+  if (options.action === "delete" && !/^[A-Za-z0-9_-]{1,64}$/.test(options.cloudId ?? "")) throw new CliError("--delete needs a cloud artifact id from --list");
+  const server = serverClient(options.projectDir);
+  const call = async (method, route, body) => {
+    const { status, json } = await server.call(method, route, body);
+    if (status === 401) throw new CliError("", { type: "login-required", url: json.loginUrl, message: "Open url to sign in to the Ryugi cloud, then run the same command again." }, 2);
+    const details = cloudErrorDetails(json);
+    if (status === 402 && details.code === "plan_limit") throw new CliError("", { type: "plan-limit", message: json.error, status, ...details }, 2);
+    if (status < 200 || status >= 300) throw new CliError(json.error || `HTTP ${status}`, { status, ...details, ...json.reasons ? { reasons: json.reasons } : {} });
+    return json;
+  };
+  const { action, artifact, cloudId } = options;
+  if (action === "list") emit({ type: "cloud-artifacts", artifacts: (await call("GET", "/api/cloud/artifacts")).artifacts });
+  else if (action === "delete") {
+    await call("DELETE", `/api/cloud/artifacts/${cloudId}`);
+    emit({ type: "deleted", id: cloudId });
+  } else if (action === "login") emit({ type: "login", url: (await call("POST", "/api/cloud/login")).url, message: "Open url to sign in to the Ryugi cloud." });
+  else if (action === "logout") {
+    await call("POST", "/api/cloud/logout");
+    emit({ type: "logged-out" });
+  } else if (action === "unpublish") {
+    await call("DELETE", `/api/cloud/publish/${artifact}`);
+    emit({ type: "unpublished", artifact });
+  } else {
+    const published = await call("POST", `/api/cloud/publish/${artifact}`, options.visibility ? { visibility: options.visibility } : void 0);
+    emit({ type: "published", artifact, url: published.url, visibility: published.visibility });
+  }
+  return 0;
+}
+var ACTIONS = ["unpublish", "list", "delete", "login", "logout"];
+var publishCommand = {
+  name: "publish",
+  summary: "Publish an artifact to the Ryugi cloud (needs a running server)",
+  usage: [
+    "--artifact <type>/<id> [--public | --private] [--unpublish] [options]",
+    "--list | --delete <cloud-id> | --login | --logout [options]"
+  ],
+  options: {
+    artifact: { type: "string", value: "<type>/<id>", help: "The artifact to publish or unpublish" },
+    public: { type: "boolean", help: "Anyone with the link can open it" },
+    private: { type: "boolean", help: "Only you can open it" },
+    unpublish: { type: "boolean", help: "Remove the artifact's cloud copy" },
+    list: { type: "boolean", help: "List your cloud artifacts" },
+    delete: { type: "string", value: "<cloud-id>", help: "Delete a cloud artifact by its id from --list" },
+    login: { type: "boolean", help: "Sign in to the Ryugi cloud" },
+    logout: { type: "boolean", help: "Sign out of the Ryugi cloud" }
+  },
+  run: ({ values, projectDir }, emit) => {
+    const actions = ACTIONS.filter((name) => values[name] !== void 0 && values[name] !== false);
+    if (actions.length > 1) throw new CliError(`Choose one of --${actions.join(", --")}`);
+    return publish({
+      projectDir,
+      action: actions[0] ?? "publish",
+      artifact: values.artifact,
+      visibility: values.public ? "public" : values.private ? "private" : void 0,
+      cloudId: values.delete
+    }, emit);
+  },
+  text: (value) => {
+    if (value.type === "login-required" || value.type === "login") return `${value.message}
+${value.url}`;
+    if (value.type === "published") return `${value.url} (${value.visibility})`;
+    return null;
+  }
+};
 
 // src/cli/start.ts
 var import_node_child_process4 = require("node:child_process");
@@ -14782,23 +15100,28 @@ var import_node_path11 = __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_fs12 = __toESM(require("node:fs"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 
 // src/shared/ids.ts
-var ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var SLUG_SOURCE = "[a-z0-9][a-z0-9-]*";
+var ADDRESS_SOURCE = "(?:[A-Za-z0-9_-]{21}|[a-f0-9]{32})";
+var ARTIFACT_LOCATOR_SOURCE = `(?:${SLUG_SOURCE}|${ADDRESS_SOURCE})`;
+var ID_PATTERN = new RegExp(`^${SLUG_SOURCE}$`);
+var ADDRESS_PATTERN = new RegExp(`^${ADDRESS_SOURCE}$`);
 var isArtifactId = (id) => ID_PATTERN.test(id);
+var isArtifactAddress = (id) => ADDRESS_PATTERN.test(id);
 var isArtifactType = (type) => ARTIFACT_TYPES.includes(type);
 
 // src/server/artifacts.ts
-function artifactKeyOf(relative) {
+function artifactKeyOf(relative, isId = isArtifactId) {
   const [type, id] = relative.split("/");
-  if (!type || !id || !isArtifactType(type) || !isArtifactId(id)) return null;
+  if (!type || !id || !isArtifactType(type) || !isId(id)) return null;
   return { type, id };
 }
 
 // src/server/artifact-address.ts
+var newArtifactId = customAlphabet2("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 21);
 function artifactId(dir) {
   const file = import_node_path10.default.join(dir, ".artifact-id");
   let id;
@@ -14806,7 +15129,7 @@ function artifactId(dir) {
     id = import_node_fs12.default.readFileSync(file, "utf8").trim();
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    id = import_node_crypto2.default.randomBytes(16).toString("hex");
+    id = newArtifactId();
     try {
       import_node_fs12.default.writeFileSync(file, `${id}
 `, { flag: "wx" });
@@ -14815,7 +15138,7 @@ function artifactId(dir) {
       return artifactId(dir);
     }
   }
-  if (!/^[a-f0-9]{32}$/.test(id)) throw new Error(`Invalid artifact ID in ${file}`);
+  if (!isArtifactAddress(id)) throw new Error(`Invalid artifact ID in ${file}`);
   return id;
 }
 function artifactPath(root, type, slug) {
@@ -14827,8 +15150,8 @@ function artifactPath(root, type, slug) {
 
 // src/server/browser-focus.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_util = require("node:util");
-var execute = (0, import_node_util.promisify)(import_node_child_process3.execFile);
+var import_node_util2 = require("node:util");
+var execute = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
 var MAC_FOCUS_SCRIPT = String.raw`
 function run(urls) {
   function key(url) {
@@ -15074,118 +15397,232 @@ async function start(options, emit) {
     unlock();
   }
 }
-
-// src/cli/publish.ts
-async function publish(options, emit) {
-  if (options.action === "publish" || options.action === "unpublish") {
-    if (!options.artifact) throw new CliError("--artifact <type>/<id> is required");
-    if (!ARTIFACT_PATTERN.test(options.artifact)) throw new CliError(ARTIFACT_ERROR);
+var startCommand = {
+  name: "start",
+  summary: "Start the project's artifacts server, or reuse the running one",
+  options: {
+    artifact: { type: "string", value: "<type>/<id>", help: "Also print a link that opens this artifact" },
+    host: { type: "string", value: "<host>", help: "Interface to listen on (default: 127.0.0.1)" },
+    "url-host": { type: "string", value: "<host>", help: "Host in printed URLs (default: localhost for a loopback --host)" },
+    "idle-timeout-minutes": { type: "string", value: "<n>", help: "Stop after this many idle minutes (default: 240)" },
+    open: { type: "boolean", help: "Open the artifact in a browser even when ARTIFACTS_OPEN=0" },
+    "no-open": { type: "boolean", help: "Do not open a browser" },
+    foreground: { type: "boolean", help: "Run the server in this process until Ctrl+C" },
+    "no-daemon": { type: "boolean" },
+    background: { type: "boolean", help: "Detach the server even where it would run in the foreground" },
+    daemon: { type: "boolean" }
+  },
+  run: ({ values, projectDir }, emit) => start({
+    projectDir,
+    artifact: values.artifact,
+    host: values.host ?? "127.0.0.1",
+    urlHost: values["url-host"],
+    idleTimeoutMinutes: values["idle-timeout-minutes"],
+    open: values["no-open"] ? false : values.open ? true : process.env.ARTIFACTS_OPEN !== "0",
+    foreground: !!(values.foreground || values["no-daemon"]),
+    background: !!(values.background || values.daemon)
+  }, emit),
+  text: (value) => value.type === "server-started" ? `${value.cloudLink ?? value.link ?? value.url}${value.reused ? " (already running)" : ""}` : null
+};
+
+// src/cli/update.ts
+var import_node_child_process6 = require("node:child_process");
+var import_node_fs15 = __toESM(require("node:fs"), 1);
+
+// src/cli/update-hint.ts
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_os7 = __toESM(require("node:os"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
+var CHECK_MS = 24 * 60 * 60 * 1e3;
+var RELEASE = /^\d+\.\d+\.\d+$/;
+function newer(a, b) {
+  const x = a.split(".").map(Number);
+  const y = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i];
+  return false;
+}
+function updateCheck({ current, cached, now, env, tty, json, argv = [] }) {
+  if (!tty || json || env.CI || env.NO_UPDATE_NOTIFIER || env.RYUGI_ARTIFACTS_COMMAND) return { hint: null, refresh: false };
+  const latest = cached?.version ?? "";
+  const quiet = argv[0] === "update" || wantsHelp(argv);
+  const hint = !quiet && RELEASE.test(current) && RELEASE.test(latest) && newer(latest, current) ? `ryugi-artifacts ${latest} is available (you have ${current}). Run \`ryugi-artifacts update\` to install it.` : null;
+  return { hint, refresh: !cached || now - cached.checkedAt >= CHECK_MS };
+}
+var latestFile = (env) => import_node_path12.default.join(env.XDG_CACHE_HOME || import_node_path12.default.join(import_node_os7.default.homedir(), ".cache"), "ryugi", "artifacts", "latest.json");
+function readLatest(file) {
+  try {
+    const { version, checkedAt } = JSON.parse(import_node_fs14.default.readFileSync(file, "utf8"));
+    return typeof version === "string" && typeof checkedAt === "number" ? { version, checkedAt } : null;
+  } catch {
+    return null;
   }
-  if (options.action === "delete" && !/^[A-Za-z0-9_-]{1,64}$/.test(options.cloudId ?? "")) throw new CliError("--delete needs a cloud artifact id from --list");
-  const server = serverClient(options.projectDir);
-  const call = async (method, route, body) => {
-    const { status, json } = await server.call(method, route, body);
-    if (status === 401) throw new CliError("", { type: "login-required", url: json.loginUrl, message: "Open url to sign in to the Ryugi cloud, then run the same command again." }, 2);
-    const details = cloudErrorDetails(json);
-    if (status === 402 && details.code === "plan_limit") throw new CliError("", { type: "plan-limit", message: json.error, status, ...details }, 2);
-    if (status < 200 || status >= 300) throw new CliError(json.error || `HTTP ${status}`, { status, ...details, ...json.reasons ? { reasons: json.reasons } : {} });
-    return json;
-  };
-  const { action, artifact, cloudId } = options;
-  if (action === "list") emit({ type: "cloud-artifacts", artifacts: (await call("GET", "/api/cloud/artifacts")).artifacts });
-  else if (action === "delete") {
-    await call("DELETE", `/api/cloud/artifacts/${cloudId}`);
-    emit({ type: "deleted", id: cloudId });
-  } else if (action === "login") emit({ type: "login", url: (await call("POST", "/api/cloud/login")).url, message: "Open url to sign in to the Ryugi cloud." });
-  else if (action === "logout") {
-    await call("POST", "/api/cloud/logout");
-    emit({ type: "logged-out" });
-  } else if (action === "unpublish") {
-    await call("DELETE", `/api/cloud/publish/${artifact}`);
-    emit({ type: "unpublished", artifact });
-  } else {
-    const published = await call("POST", `/api/cloud/publish/${artifact}`, options.visibility ? { visibility: options.visibility } : void 0);
-    emit({ type: "published", artifact, url: published.url, visibility: published.visibility });
+}
+function writeLatest(file, version, checkedAt) {
+  try {
+    import_node_fs14.default.mkdirSync(import_node_path12.default.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}`;
+    import_node_fs14.default.writeFileSync(tmp, JSON.stringify({ version, checkedAt }));
+    import_node_fs14.default.renameSync(tmp, file);
+  } catch {
   }
-  return 0;
 }
-
-// src/cli/main.ts
-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
-running until Ctrl+C.
-
-Commands:
-  start     Start the project's artifacts server, or reuse the running one
-  stop      Stop the project's artifacts server; the artifacts are kept
-  check     Wait until the server has checked the latest write, then print its warnings (needs a running server):
-              --artifact <type>/<id>
-  publish   Publish an artifact to the Ryugi cloud (needs a running server):
-              --artifact <type>/<id> [--public | --private] [--unpublish]
-              --list | --delete <cloud-id> | --login | --logout
-  comment   Read and answer comments on a document or artboard (needs a running server):
-              list    --artifact <document|artboard>/<id> [--all]   what changed since you last listed
-              add     --artifact document/<id> --block <blockId> [--quote <text>] [--text <text>]
-              add     --artifact artboard/<id> --board <boardId> [--x <px> --y <px>] [--text <text>]
-              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.
-  get       Read a published Ryugi Cloud artifact by link or id, signed in as this machine's
-            cloud account. Prints the source (a document's LiteXML and comments) unless --json;
-            artboard and HTML files, and files a document uses, are downloaded to --out
-            or ~/.cache/ryugi/get/<id>/:
-              <link-or-id> [--out <dir>] [--no-comments]
-  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
-            Without --auto-publish, prints the current values.
-
-Options:
-  --project-dir <path>  Project directory (default: current directory)
-  --json                Print one JSON line (default when not in a terminal)
-  -v, --version         Print the version
-  --no-open             Print the URL without opening a browser
-  -h, --help            Show this help`;
-var common = { "project-dir": { type: "string" }, json: { type: "boolean" } };
-function parse5(args, options, positionals = 0) {
+var REFRESH = `
+const fs = require('node:fs');
+const path = require('node:path');
+const [file, registry] = process.argv.slice(1);
+fetch(new URL('ryugi-artifacts/latest', registry), { signal: AbortSignal.timeout(10000) })
+  .then((res) => res.json())
+  .then(({ version }) => {
+    if (!/^\\d+\\.\\d+\\.\\d+/.test(version || '')) return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = file + '.' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify({ version, checkedAt: Date.now() }));
+    fs.renameSync(tmp, file);
+  })
+  .catch(() => {});
+`;
+function refreshLatest(file, registry2) {
+  const base = registry2.endsWith("/") ? registry2 : `${registry2}/`;
+  const child = (0, import_node_child_process5.spawn)(process.execPath, ["-e", REFRESH, file, base], { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function notifyUpdate(current, json, argv) {
+  const file = latestFile(process.env);
+  const { hint, refresh } = updateCheck({ current, cached: readLatest(file), now: Date.now(), env: process.env, tty: !!process.stderr.isTTY, json, argv });
+  if (hint) console.error(hint);
+  if (refresh) refreshLatest(file, process.env.npm_config_registry || "https://registry.npmjs.org/");
+}
+
+// src/cli/update.ts
+var PACKAGE = "ryugi-artifacts";
+var PMS = ["npm", "pnpm", "yarn", "bun"];
+var TRANSIENT = [
+  ["npx", ["/_npx/"]],
+  ["pnpm dlx", ["/pnpm/dlx/", "/.pnpm-store/dlx/"]],
+  ["bunx", ["/bunx-", "/.bun/install/cache/"]]
+];
+var GLOBAL = [
+  ["pnpm", ["/pnpm/global/"]],
+  ["yarn", ["/yarn/global/"]],
+  ["bun", ["/.bun/install/global/"]],
+  ["npm", [`/lib/node_modules/${PACKAGE}/`, `/npm/node_modules/${PACKAGE}/`]]
+];
+function detectInstall(file, env) {
+  if (env.RYUGI_ARTIFACTS_COMMAND) return { kind: "launcher" };
+  let real = file;
   try {
-    const parsed = (0, import_node_util2.parseArgs)({ args, options: { ...common, ...options }, allowPositionals: positionals > 0, strict: true });
-    if (parsed.positionals.length > positionals) throw new CliError(`Unknown argument: ${parsed.positionals[positionals]}`);
-    return parsed;
+    real = import_node_fs15.default.realpathSync(file);
+  } catch {
+  }
+  const normalized = real.replace(/\\/g, "/").toLowerCase();
+  const has = (markers) => markers.some((marker) => normalized.includes(marker));
+  for (const [runner, markers] of TRANSIENT) if (has(markers)) return { kind: "transient", runner };
+  for (const [pm, markers] of GLOBAL) if (has(markers)) return { kind: "global", pm };
+  return normalized.includes("/node_modules/") ? { kind: "unknown" } : { kind: "local" };
+}
+function installCommand(pm, version) {
+  const target = `${PACKAGE}@${version}`;
+  const args = pm === "npm" ? ["install", "-g", target] : pm === "yarn" ? ["global", "add", target] : ["add", "-g", target];
+  return { cmd: pm, args };
+}
+var commandLine2 = ({ cmd, args }) => [cmd, ...args].join(" ");
+async function fetchLatest(registry2) {
+  const base = registry2.endsWith("/") ? registry2 : `${registry2}/`;
+  try {
+    const res = await fetch(new URL(`${PACKAGE}/latest`, base), { signal: AbortSignal.timeout(1e4) });
+    const { version } = await res.json();
+    if (res.ok && typeof version === "string" && /^\d+\.\d+\.\d+/.test(version)) return version;
+    throw new Error(`registry returned ${res.status}`);
   } catch (err) {
-    if (err instanceof CliError) throw err;
-    const flag = /'([^']+)'/.exec(err.message)?.[1];
-    throw new CliError(flag ? `Unknown argument: ${flag.split(" ")[0]}` : err.message);
+    throw new CliError(`Could not get the latest ${PACKAGE} version from ${base}: ${err.message}`);
   }
 }
+function advice(install, latest) {
+  if (install.kind === "transient") return `You ran ${PACKAGE} through ${install.runner}, which keeps no install to update. Run \`${install.runner} ${PACKAGE}@latest\` to get ${latest}.`;
+  if (install.kind === "local") return "This is a local build from a Ryugi checkout. Update it with `git pull`, then `pnpm build` in artifacts/.";
+  if (install.kind === "launcher") return `The Ryugi skill runs ${PACKAGE} through its launcher, which moves to ${latest} within a day of its release.`;
+  return null;
+}
+async function update2(options, emit) {
+  if (options.pm !== void 0 && !PMS.includes(options.pm)) throw new CliError(`--pm must be one of ${PMS.join(", ")}`);
+  const install = options.pm ? { kind: "global", pm: options.pm } : detectInstall(options.file, options.env);
+  const latest = await fetchLatest(options.registry);
+  writeLatest(latestFile(options.env), latest, Date.now());
+  const report = { type: "update-check", current: options.current, latest, install: install.kind };
+  if (!newer(latest, options.current)) {
+    emit({ ...report, upToDate: true, command: null });
+    return 0;
+  }
+  if (install.kind === "unknown") {
+    const commands = PMS.map((pm) => `  ${commandLine2(installCommand(pm, latest))}`).join("\n");
+    throw new CliError(`Could not tell how ${PACKAGE} was installed (${options.file}). Install ${latest} with one of:
+${commands}
+or run \`${PACKAGE} update --pm <${PMS.join("|")}>\`.`);
+  }
+  if (install.kind !== "global") {
+    emit({ ...report, upToDate: false, command: null, message: advice(install, latest) });
+    return 0;
+  }
+  const command = installCommand(install.pm, latest);
+  if (options.check) {
+    emit({ ...report, upToDate: false, command: commandLine2(command) });
+    return 0;
+  }
+  const windows = process.platform === "win32";
+  const result = windows ? (0, import_node_child_process6.spawnSync)(commandLine2(command), { stdio: ["inherit", 2, 2], env: options.env, shell: true }) : (0, import_node_child_process6.spawnSync)(command.cmd, command.args, { stdio: ["inherit", 2, 2], env: options.env });
+  if (result.error) throw new CliError(`Could not run ${commandLine2(command)}: ${result.error.message}`);
+  if (result.status !== 0) throw new CliError(`${commandLine2(command)} exited with ${result.status ?? result.signal}`);
+  emit({ type: "updated", from: options.current, to: latest, pm: install.pm, command: commandLine2(command) });
+  return 0;
+}
+var updateCommand = {
+  name: "update",
+  summary: "Install the newest ryugi-artifacts release with the package manager that installed this one",
+  options: {
+    check: { type: "boolean", help: "Compare versions only; do not install" },
+    pm: { type: "string", value: "<npm|pnpm|yarn|bun>", help: "Use this package manager instead of detecting it" }
+  },
+  run: ({ values }, emit) => update2({
+    current: "1.44.0",
+    file: __filename,
+    env: process.env,
+    registry: process.env.npm_config_registry || "https://registry.npmjs.org/",
+    check: !!values.check,
+    pm: values.pm
+  }, emit),
+  text: (value) => {
+    if (value.type === "updated") return `Updated ${PACKAGE} ${value.from} \u2192 ${value.to} with ${value.pm}. Running servers keep the old version until you run \`${PACKAGE} stop\`.`;
+    if (value.type !== "update-check") return null;
+    if (value.upToDate) return `${PACKAGE} ${value.current} is the latest release.`;
+    return value.message ?? `${PACKAGE} ${value.latest} is available (you have ${value.current}). Run: ${value.command}`;
+  }
+};
+
+// src/cli/commands.ts
+var COMMANDS = [startCommand, stopCommand, checkCommand, publishCommand, commentCommand, getCommand, monitorCommand, configCommand, updateCommand];
+
+// src/cli/main.ts
+var BROWSE_OPTIONS = { "no-open": { type: "boolean", help: "Print the URL without opening a browser" } };
 function text(value) {
   if (typeof value.error === "string") return `Error: ${value.error}`;
-  if (value.type === "server-started") return `${value.cloudLink ?? value.link ?? value.url}${value.reused ? " (already running)" : ""}`;
-  if (value.type === "login-required" || value.type === "login") return `${value.message}
-${value.url}`;
-  if (value.type === "published") return `${value.url} (${value.visibility})`;
-  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;
+  for (const command of COMMANDS) {
+    const line = command.text?.(value);
+    if (line != null) return line;
+  }
   if (typeof value.status === "string") return value.status === "stopped" ? "Stopped." : value.status.replace(/_/g, " ");
   return JSON.stringify(value);
 }
 function openBrowser2(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_process5.execFile)(command, args, () => {
+  (0, import_node_child_process7.execFile)(command, args, () => {
   });
 }
 async function browse(argv) {
-  const { values, positionals } = parse5(argv, { "no-open": { type: "boolean" } }, 1);
+  const { values, positionals } = parse(argv, BROWSE_OPTIONS, 1);
   if (positionals.length && values["project-dir"]) throw new CliError("Specify one project directory.");
   return start({
     projectDir: values["project-dir"] ?? positionals[0] ?? process.cwd(),
@@ -15204,140 +15641,30 @@ async function browse(argv) {
     if (!values["no-open"]) openBrowser2(value.url);
   });
 }
-async function getCommand(argv) {
-  const json = argv.includes("--json");
-  try {
-    const { values, positionals } = parse5(argv, { "no-comments": { type: "boolean" }, out: { type: "string" } }, 1);
-    if (!positionals[0]) throw new CliError("Give a Ryugi Cloud link or artifact id.");
-    const result = await getArtifact({
-      target: positionals[0],
-      defaultOrigin: (process.env.RYUGI_CLOUD_ORIGIN || "https://ryugi.innei.dev").replace(/\/+$/, ""),
-      credentialsFile: credentialsFile(process.env, process.platform, import_node_os6.default.homedir()),
-      cacheRoot: import_node_path12.default.join(process.env.XDG_CACHE_HOME || import_node_path12.default.join(import_node_os6.default.homedir(), ".cache"), "ryugi", "get"),
-      out: values.out
-    });
-    if (json) console.log(JSON.stringify(result));
-    else process.stdout.write(getText4(result, { comments: !values["no-comments"] }));
-    return 0;
-  } catch (caught) {
-    const err = caught instanceof CliError ? caught : new CliError(caught.message);
-    const fields = err.message ? { error: err.message, ...err.fields } : err.fields;
-    if (json) console.log(JSON.stringify(fields));
-    else console.error(err.message ? `Error: ${err.message}` : String(err.fields.message));
-    return err.code;
-  }
-}
 async function main(argv) {
-  const [command, ...rest] = argv;
-  if (command === "get") return getCommand(rest);
-  const json = argv.includes("--json") || !process.stdout.isTTY;
+  const [name, ...rest] = argv;
+  const command = COMMANDS.find((candidate) => candidate.name === name);
+  const json = argv.includes("--json") || !command?.explicitJson && !process.stdout.isTTY;
+  notifyUpdate("1.44.0", json, argv);
   const emit = (value) => {
     const line = json ? JSON.stringify(value) : text(value);
     if (!json && typeof value.error === "string") console.error(line);
     else console.log(line);
   };
   try {
-    if (command === "start") {
-      const { values } = parse5(rest, {
-        artifact: { type: "string" },
-        host: { type: "string" },
-        "url-host": { type: "string" },
-        "idle-timeout-minutes": { type: "string" },
-        open: { type: "boolean" },
-        "no-open": { type: "boolean" },
-        foreground: { type: "boolean" },
-        "no-daemon": { type: "boolean" },
-        background: { type: "boolean" },
-        daemon: { type: "boolean" }
-      });
-      return await start({
-        projectDir: values["project-dir"] ?? process.cwd(),
-        artifact: values.artifact,
-        host: values.host ?? "127.0.0.1",
-        urlHost: values["url-host"],
-        idleTimeoutMinutes: values["idle-timeout-minutes"],
-        open: values["no-open"] ? false : values.open ? true : process.env.ARTIFACTS_OPEN !== "0",
-        foreground: !!(values.foreground || values["no-daemon"]),
-        background: !!(values.background || values.daemon)
-      }, emit);
-    }
-    if (command === "stop") {
-      const { values, positionals } = parse5(rest, {}, 1);
-      return await stop(values["project-dir"] ?? positionals[0] ?? process.cwd(), emit);
-    }
-    if (command === "check") {
-      const { values } = parse5(rest, { artifact: { type: "string" } });
-      return await check({
-        projectDir: values["project-dir"] ?? process.cwd(),
-        artifact: values.artifact
-      }, emit);
-    }
-    if (command === "publish") {
-      const { values } = parse5(rest, {
-        artifact: { type: "string" },
-        public: { type: "boolean" },
-        private: { type: "boolean" },
-        unpublish: { type: "boolean" },
-        list: { type: "boolean" },
-        delete: { type: "string" },
-        login: { type: "boolean" },
-        logout: { type: "boolean" }
-      });
-      const actions = ["unpublish", "list", "delete", "login", "logout"].filter((name) => values[name] !== void 0 && values[name] !== false);
-      if (actions.length > 1) throw new CliError(`Choose one of --${actions.join(", --")}`);
-      const action = actions[0] ?? "publish";
-      return await publish({
-        projectDir: values["project-dir"] ?? process.cwd(),
-        action,
-        artifact: values.artifact,
-        visibility: values.public ? "public" : values.private ? "private" : void 0,
-        cloudId: values.delete
-      }, emit);
-    }
-    if (command === "comment") {
-      const { values, positionals } = parse5(rest, {
-        artifact: { type: "string" },
-        all: { type: "boolean" },
-        block: { type: "string" },
-        quote: { type: "string" },
-        thread: { type: "string" },
-        text: { type: "string" },
-        board: { type: "string" },
-        x: { type: "string" },
-        y: { type: "string" }
-      }, 1);
-      return await comment({
-        projectDir: values["project-dir"] ?? process.cwd(),
-        action: positionals[0],
-        artifact: values.artifact,
-        all: values.all,
-        block: values.block,
-        quote: values.quote,
-        thread: values.thread,
-        text: values.text,
-        board: values.board,
-        x: values.x,
-        y: values.y
-      }, emit);
-    }
-    if (command === "config") {
-      const { values } = parse5(rest, { "auto-publish": { type: "string" }, project: { type: "boolean" } });
-      return config({
-        projectDir: values["project-dir"] ?? process.cwd(),
-        autoPublish: values["auto-publish"],
-        project: !!values.project
-      }, emit);
-    }
-    if (command === "monitor") {
-      const { values } = parse5(rest, {});
-      return await monitor({ json: !!values.json }, emit);
-    }
-    if (command === "--version" || command === "-v") {
-      console.log("1.43.0");
+    if (command) {
+      if (wantsHelp(rest)) {
+        console.log(commandHelp(command));
+        return 0;
+      }
+      return await command.run(parse(rest, command.options, command.positionals), emit);
+    }
+    if (name === "--version" || name === "-v") {
+      console.log("1.44.0");
       return 0;
     }
-    if (command === "--help" || command === "-h") {
-      console.log(HELP2);
+    if (name === "--help" || name === "-h") {
+      console.log(rootHelp(COMMANDS, BROWSE_OPTIONS));
       return 0;
     }
     return await browse(argv);