ryugi-artifacts 1.7.4 → 1.9.0

package/bin/ryugi-artifacts.cjs

@@ -1,53 +1,2 @@
 #!/usr/bin/env node
-const { execFile, spawn } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-const readline = require('node:readline');
-const { parseArgs } = require('node:util');
-
-try {
-  const { values, positionals } = parseArgs({
-    options: {
-      help: { type: 'boolean', short: 'h' },
-      'no-open': { type: 'boolean' },
-      'project-dir': { type: 'string' },
-    },
-    allowPositionals: true,
-  });
-  if (values.help) {
-    console.log('Usage: ryugi-artifacts [project-directory] [--no-open]\n\nOpen the current project’s artifacts in your browser.\n\n  --project-dir <path>  Project directory (default: current directory)\n  --no-open             Print the URL without opening a browser\n  -h, --help            Show this help\n\nRequires Node.js and Bash (Git Bash on Windows).');
-  } else {
-    if (positionals.length > 1 || (positionals.length && values['project-dir'])) throw new Error('Specify one project directory.');
-    const project = fs.realpathSync(path.resolve(values['project-dir'] || positionals[0] || process.cwd()));
-    if (!fs.statSync(project).isDirectory()) throw new Error('Project path must be a directory.');
-    const child = spawn('bash', [path.join(__dirname, '../dist/start-server.sh'), '--project-dir', project, '--foreground', '--no-open'], {
-      stdio: ['inherit', 'pipe', 'inherit'],
-    });
-    let interrupted = false;
-    for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => {
-      interrupted = true;
-      child.kill('SIGTERM');
-    });
-    child.on('error', (error) => {
-      console.error(`Could not start artifacts: ${error.message}. Bash is required (Git Bash on Windows).`);
-      process.exitCode = 1;
-    });
-    readline.createInterface({ input: child.stdout }).on('line', (line) => {
-      let info;
-      try { info = JSON.parse(line); } catch { console.error(line); return; }
-      if (info.error) console.error(info.error);
-      if (info.type !== 'server-started') return;
-      console.log(info.url);
-      if (!info.reused) console.log('Press Ctrl+C to stop the server.');
-      if (values['no-open']) return;
-      const platform = process.platform;
-      const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
-      const args = platform === 'win32' ? ['/c', 'start', '""', info.url] : [info.url];
-      execFile(command, args, () => {});
-    });
-    child.on('close', (code) => { process.exitCode = interrupted ? 0 : code ?? 1; });
-  }
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}
+require('../dist/cli.cjs');

package/dist/cli.cjs

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/main.ts
+var import_node_child_process3 = require("node:child_process");
+var import_node_util = require("node:util");
+
+// src/cli/paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var CliError = class extends Error {
+  constructor(message, fields = {}, code = 1) {
+    super(message);
+    this.fields = fields;
+    this.code = code;
+  }
+  fields;
+  code;
+};
+function projectPaths(dir) {
+  let project;
+  try {
+    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}`);
+  }
+  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_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 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/start.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_readline = __toESM(require("node:readline"), 1);
+
+// src/server/agent.ts
+var NAMES = {
+  claude: "Claude Code",
+  "claude-code": "Claude Code",
+  cowork: "Claude Cowork",
+  codex: "Codex",
+  cursor: "Cursor",
+  "cursor-cli": "Cursor",
+  gemini: "Gemini CLI",
+  "gemini-cli": "Gemini CLI",
+  "github-copilot": "GitHub Copilot",
+  "github-copilot-cli": "GitHub Copilot",
+  kilo: "Kilo Code",
+  opencode: "OpenCode",
+  "qwen-code": "Qwen Code",
+  antigravity: "Antigravity",
+  augment: "Augment",
+  "augment-cli": "Augment",
+  goose: "Goose",
+  amp: "Amp",
+  cline: "Cline",
+  roo: "Roo Code",
+  devin: "Devin",
+  replit: "Replit",
+  v0: "v0"
+};
+var AGENT_DISPLAY_NAMES = [...new Set(Object.values(NAMES))];
+var AGENT_MARKERS = [
+  "AI_AGENT",
+  "AGENT",
+  "CLAUDE_CODE_IS_COWORK",
+  "KILO",
+  "CODEX_THREAD_ID",
+  "CODEX_SANDBOX",
+  "CODEX_CI",
+  "CURSOR_AGENT",
+  "CURSOR_TRACE_ID",
+  "GEMINI_CLI",
+  "COPILOT_CLI",
+  "OPENCODE",
+  "OPENCODE_CLIENT",
+  "QWEN_CODE",
+  "ANTIGRAVITY_AGENT",
+  "AUGMENT_AGENT",
+  "CLINE_ACTIVE",
+  "ROO_ACTIVE",
+  "CLAUDECODE",
+  "CLAUDE_CODE"
+];
+
+// src/cli/process.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function commandLine(pid) {
+  try {
+    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" });
+  if (direct.status === 0 && direct.stdout.trim()) return direct.stdout.trim().split(/\s+/);
+  const full = (0, import_node_child_process.spawnSync)("ps", ["-f", "-p", String(pid)], { encoding: "utf8" });
+  if (full.status !== 0) return null;
+  const line = full.stdout.split("\n").slice(1).join(" ").trim();
+  return line ? line.split(/\s+/) : null;
+}
+function hasServerId(pid, id) {
+  if (!alive(pid)) return false;
+  if (process.platform === "win32") return true;
+  return commandLine(pid)?.includes(`--artifacts-server-id=${id}`) ?? false;
+}
+function parentOf(pid) {
+  if (process.platform === "win32") return null;
+  const result = (0, import_node_child_process.spawnSync)("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8" });
+  const parent = Number(result.stdout.trim());
+  return Number.isInteger(parent) && parent > 1 ? parent : null;
+}
+async function waitForExit(pid, ms) {
+  for (let waited = 0; waited < ms && alive(pid); waited += 100) await sleep(100);
+  return !alive(pid);
+}
+var readText = (file) => {
+  try {
+    return import_node_fs2.default.readFileSync(file, "utf8").replace(/[\r\n]+$/, "");
+  } catch {
+    return null;
+  }
+};
+
+// src/cli/start.ts
+var windowsLike = () => process.platform === "win32";
+function withLink(info, artifact, reused) {
+  const out = { ...info };
+  if (reused) out.reused = true;
+  if (artifact && typeof out.url === "string") {
+    const url = new URL(out.url);
+    out.link = `${url.origin}/${artifact}?key=${url.searchParams.get("key")}`;
+  }
+  return out;
+}
+async function acquireLock(lock) {
+  for (let attempt = 0; attempt < 150; attempt++) {
+    try {
+      import_node_fs3.default.mkdirSync(lock);
+      return true;
+    } catch {
+    }
+    try {
+      if (Date.now() - import_node_fs3.default.statSync(lock).mtimeMs > 6e4) {
+        import_node_fs3.default.rmdirSync(lock);
+        continue;
+      }
+    } catch {
+    }
+    await sleep(100);
+  }
+  return false;
+}
+function runningPid(paths) {
+  const pid = Number(readText(paths.pid));
+  const id = readText(paths.serverId);
+  if (!Number.isInteger(pid) || pid <= 0 || !id) return null;
+  return hasServerId(pid, id) ? pid : null;
+}
+function ownerPid() {
+  if (windowsLike()) return null;
+  const given = Number(process.env.RYUGI_ARTIFACTS_OWNER);
+  if (Number.isInteger(given) && given > 1) return given;
+  return parentOf(process.ppid) ?? process.ppid;
+}
+function registerOwner(paths) {
+  const owners = /* @__PURE__ */ new Set();
+  for (const line of (readText(paths.owners) ?? "").split("\n")) {
+    const pid = Number(line.trim());
+    if (Number.isInteger(pid) && pid > 1 && alive(pid)) owners.add(pid);
+  }
+  const owner = ownerPid();
+  if (owner) owners.add(owner);
+  const tmp = `${paths.owners}.${process.pid}`;
+  import_node_fs3.default.writeFileSync(tmp, [...owners].sort((a, b) => a - b).map((pid) => `${pid}
+`).join(""));
+  import_node_fs3.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_fs3.default.writeFileSync(paths.agent, `${JSON.stringify(markers)}
+`);
+}
+async function replace(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  if (await waitForExit(pid, 5e3)) return;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  if (await waitForExit(pid, 2e3)) return;
+  throw new CliError(`The running server (pid ${pid}) is on another release and did not stop; stop it with \`ryugi-artifacts stop\` and retry`);
+}
+function serverEnv(paths, options) {
+  const env = { ...process.env, ARTIFACTS_ROOT: paths.root, ARTIFACTS_HOST: options.host, ARTIFACTS_URL_HOST: options.urlHost, ARTIFACTS_OPEN: options.open ? "1" : "0" };
+  if (options.artifact) env.ARTIFACTS_OPEN_ARTIFACT = options.artifact;
+  if (options.idleTimeoutMinutes) env.ARTIFACTS_IDLE_TIMEOUT_MS = String(Number(options.idleTimeoutMinutes) * 6e4);
+  delete env.RYUGI_ARTIFACTS_OWNER;
+  delete env.RYUGI_ARTIFACTS_VERSION;
+  return env;
+}
+async function start(options, emit) {
+  if (options.artifact !== void 0 && !ARTIFACT_PATTERN.test(options.artifact)) throw new CliError(ARTIFACT_ERROR);
+  if (options.idleTimeoutMinutes !== void 0 && (!/^\d+$/.test(options.idleTimeoutMinutes) || Number(options.idleTimeoutMinutes) < 1)) throw new CliError("--idle-timeout-minutes must be a positive integer");
+  options.urlHost ||= options.host === "127.0.0.1" || options.host === "localhost" ? "localhost" : options.host;
+  const foreground = options.foreground || !options.background && (!!process.env.CODEX_CI || windowsLike());
+  process.umask(63);
+  const paths = projectPaths(options.projectDir);
+  import_node_fs3.default.mkdirSync(paths.state, { recursive: true });
+  if (!import_node_fs3.default.existsSync(import_node_path2.default.join(paths.state, ".gitignore"))) import_node_fs3.default.writeFileSync(import_node_path2.default.join(paths.state, ".gitignore"), "*\n");
+  const server = import_node_path2.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;
+  const unlock = () => {
+    if (!locked) return;
+    locked = false;
+    try {
+      import_node_fs3.default.rmdirSync(paths.lock);
+    } catch {
+    }
+  };
+  try {
+    const running = runningPid(paths);
+    const info = readText(paths.info);
+    if (running && info) {
+      if (!version || readText(paths.version) === version) {
+        registerOwner(paths);
+        recordAgent(paths);
+        emit(withLink(JSON.parse(info), options.artifact, true));
+        return 0;
+      }
+      await replace(running);
+    }
+    registerOwner(paths);
+    recordAgent(paths);
+    import_node_fs3.default.rmSync(paths.info, { force: true });
+    const id = import_node_crypto.default.randomBytes(24).toString("hex");
+    import_node_fs3.default.writeFileSync(paths.serverId, `${id}
+`);
+    import_node_fs3.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_fs3.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) => {
+        let value;
+        try {
+          value = JSON.parse(line);
+        } catch {
+          process.stdout.write(`${line}
+`);
+          return;
+        }
+        emit(value.type === "server-started" ? withLink(value, options.artifact, false) : value);
+      });
+      const exited = new Promise((resolve) => child2.on("close", (code) => resolve(code ?? 1)));
+      for (let waited = 0; waited < 5e3 && !import_node_fs3.default.existsSync(paths.info); waited += 100) await sleep(100);
+      unlock();
+      return await exited;
+    }
+    const log = import_node_fs3.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_fs3.default.closeSync(log);
+    child.unref();
+    import_node_fs3.default.writeFileSync(paths.pid, `${child.pid}
+`);
+    for (let waited = 0; waited < 5e3; waited += 100) {
+      const lines = (readText(paths.log) ?? "").split("\n");
+      const started = lines.find((line) => line.includes('"server-started"'));
+      if (started) {
+        for (let check = 0; check < 20; check++) {
+          if (!alive(child.pid)) throw new CliError(`Server started but was killed. Retry in a persistent terminal with: ryugi-artifacts start --project-dir ${paths.project} --host ${options.host} --url-host ${options.urlHost} --foreground`);
+          await sleep(100);
+        }
+        emit(withLink(JSON.parse(started), options.artifact, false));
+        return 0;
+      }
+      const failed = lines.find((line) => line.includes('"server-error"'));
+      if (failed) {
+        emit(JSON.parse(failed));
+        return 1;
+      }
+      await sleep(100);
+    }
+    throw new CliError("Server failed to start within 5 seconds");
+  } finally {
+    unlock();
+  }
+}
+
+// src/cli/publish.ts
+var NOT_RUNNING = "No artifacts server is running for this project. Start it with `ryugi-artifacts start`, then run this again.";
+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 paths = projectPaths(options.projectDir);
+  let info;
+  try {
+    info = JSON.parse(readText(paths.info) ?? "");
+  } catch {
+    throw new CliError(NOT_RUNNING);
+  }
+  const base = new URL(info.url);
+  const key = base.searchParams.get("key") ?? "";
+  if (base.hostname === "localhost") base.hostname = "127.0.0.1";
+  const call = async (method, route, body) => {
+    let res;
+    try {
+      res = await fetch(`${base.origin}${route}?key=${encodeURIComponent(key)}`, {
+        method,
+        headers: body ? { "Content-Type": "application/json" } : {},
+        body: body ? JSON.stringify(body) : void 0
+      });
+    } catch {
+      throw new CliError(NOT_RUNNING);
+    }
+    const json = await res.json().catch(() => ({}));
+    if (res.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);
+    if (!res.ok) throw new CliError(json.error || `HTTP ${res.status}`, 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;
+}
+
+// src/cli/stop.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+async function stop(projectDir, emit) {
+  const paths = projectPaths(projectDir);
+  const markStopped = (reason) => {
+    import_node_fs4.default.rmSync(paths.info, { force: true });
+    import_node_fs4.default.mkdirSync(paths.state, { recursive: true });
+    import_node_fs4.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_fs4.default.rmSync(paths.pid, { force: true });
+    import_node_fs4.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_fs4.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]
+       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
+  publish   Publish an artifact to the Ryugi cloud (needs a running server):
+              --artifact <type>/<id> [--public | --private] [--unpublish]
+              --list | --delete <cloud-id> | --login | --logout
+
+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 parse(args, options, positionals = 0) {
+  try {
+    const parsed = (0, import_node_util.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;
+  } 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 text(value) {
+  if (typeof value.error === "string") return `Error: ${value.error}`;
+  if (value.type === "server-started") return `${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 (typeof value.status === "string") return value.status === "stopped" ? "Stopped." : value.status.replace(/_/g, " ");
+  return JSON.stringify(value);
+}
+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, () => {
+  });
+}
+async function browse(argv) {
+  const { values, positionals } = parse(argv, { "no-open": { type: "boolean" } }, 1);
+  if (positionals.length && values["project-dir"]) throw new CliError("Specify one project directory.");
+  return start({
+    projectDir: values["project-dir"] ?? positionals[0] ?? process.cwd(),
+    host: "127.0.0.1",
+    open: false,
+    foreground: true,
+    background: false
+  }, (value) => {
+    if (typeof value.error === "string") {
+      console.error(value.error);
+      return;
+    }
+    if (value.type !== "server-started") return;
+    console.log(value.url);
+    if (!value.reused) console.log("Press Ctrl+C to stop the server.");
+    if (!values["no-open"]) openBrowser(value.url);
+  });
+}
+async function main(argv) {
+  const [command, ...rest] = argv;
+  const json = argv.includes("--json") || !process.stdout.isTTY;
+  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 } = parse(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 } = parse(rest, {}, 1);
+      return await stop(values["project-dir"] ?? positionals[0] ?? process.cwd(), emit);
+    }
+    if (command === "publish") {
+      const { values } = parse(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 === "--version" || command === "-v") {
+      console.log("1.9.0");
+      return 0;
+    }
+    if (command === "--help" || command === "-h") {
+      console.log(HELP);
+      return 0;
+    }
+    return await browse(argv);
+  } catch (err) {
+    if (!(err instanceof CliError)) throw err;
+    emit(err.message ? { error: err.message, ...err.fields } : err.fields);
+    return err.code;
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.log(JSON.stringify({ error: err.message }));
+    process.exitCode = 1;
+  }
+);