ryugi-artifacts 1.11.0 → 1.12.0

package/dist/cli.cjs

@@ -295,11 +295,151 @@ function commentText(value) {
   return null;
 }
 
+// src/cli/config.ts
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
+
+// src/server/config.ts
+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/validate.ts
+var BOARD_NUMBERS = ["x", "y", "w", "h"];
+var BOARD_REQUIRED = ["file", "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) {
+  if (typeof value !== "object" || value === null) return false;
+  const { id, url, publishedAt, visibility } = value;
+  return typeof id === "string" && typeof url === "string" && (typeof publishedAt === "string" || publishedAt === null) && isVisibility(visibility);
+}
+function normalize(raw) {
+  const config2 = defaults();
+  if (typeof raw !== "object" || raw === null) return config2;
+  const { autoPublish } = raw;
+  if (typeof autoPublish === "boolean") config2.autoPublish = autoPublish;
+  const artifacts = raw.artifacts;
+  if (typeof artifacts !== "object" || artifacts === null) return config2;
+  for (const [key, value] of Object.entries(artifacts)) {
+    if (typeof value !== "object" || value === null) continue;
+    const { visibility, cloud, autoPublish: autoPublish2 } = value;
+    if (visibility !== void 0 && !isVisibility(visibility)) continue;
+    const entry = {};
+    if (visibility) entry.visibility = visibility;
+    if (isCloudRecord(cloud)) entry.cloud = { id: cloud.id, url: cloud.url, publishedAt: cloud.publishedAt, visibility: cloud.visibility };
+    if (autoPublish2 === false) entry.autoPublish = false;
+    config2.artifacts[key] = entry;
+  }
+  return config2;
+}
+function readConfig(file) {
+  let text2;
+  try {
+    text2 = import_node_fs5.default.readFileSync(file, "utf8");
+  } catch {
+    return { config: defaults() };
+  }
+  try {
+    return { config: normalize(JSON.parse(text2)) };
+  } catch (err) {
+    return { config: defaults(), warning: `config.json is not valid JSON: ${err.message}` };
+  }
+}
+function ensureGitignore(dir) {
+  const file = import_node_path3.default.join(dir, ".gitignore");
+  let current = "";
+  try {
+    current = import_node_fs5.default.readFileSync(file, "utf8");
+  } catch {
+    import_node_fs5.default.writeFileSync(file, "config.json\n");
+    return;
+  }
+  if (current.split(/\r?\n/).some((line) => line.trim() === "config.json")) return;
+  import_node_fs5.default.writeFileSync(file, `${current}${current === "" || current.endsWith("\n") ? "" : "\n"}config.json
+`);
+}
+function ensureConfig(file) {
+  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_fs5.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  writeJsonAtomic(file, config2);
+}
+
+// src/server/credentials.ts
+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");
+}
+
+// src/server/settings.ts
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+var settingsFileFor = (credentialsFile2) => import_node_path5.default.join(import_node_path5.default.dirname(credentialsFile2), "config.json");
+function readSettings(file) {
+  try {
+    const raw = JSON.parse(import_node_fs6.default.readFileSync(file, "utf8"));
+    return typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function readGlobalAutoPublish(file) {
+  const value = readSettings(file).autoPublish;
+  return typeof value === "boolean" ? value : void 0;
+}
+function writeGlobalAutoPublish(file, value) {
+  import_node_fs6.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true, mode: 448 });
+  writeJsonAtomic(file, { ...readSettings(file), autoPublish: value });
+}
+
+// src/cli/config.ts
+var VALUES = { on: true, off: false, inherit: null };
+function config(options, emit) {
+  const globalFile = settingsFileFor(credentialsFile(process.env, process.platform, import_node_os.default.homedir()));
+  const projectFile = import_node_path6.default.join(import_node_path6.default.dirname(projectPaths(options.projectDir).root), "config.json");
+  if (options.autoPublish !== void 0) {
+    const value = VALUES[options.autoPublish];
+    if (value === void 0) throw new CliError("--auto-publish takes on, off, or (with --project) inherit");
+    if (options.project) {
+      ensureConfig(projectFile);
+      setProjectAutoPublish(projectFile, value);
+    } else if (value === null) throw new CliError("inherit only applies with --project");
+    else writeGlobalAutoPublish(globalFile, value);
+  }
+  emit({ type: "auto-publish", global: readGlobalAutoPublish(globalFile) ?? null, project: readConfig(projectFile).config.autoPublish ?? null });
+  return 0;
+}
+
 // 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_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 var windowsLike = () => process.platform === "win32";
 function withLink(info, artifact, reused) {
@@ -314,13 +454,13 @@ function withLink(info, artifact, reused) {
 async function acquireLock(lock) {
   for (let attempt = 0; attempt < 150; attempt++) {
     try {
-      import_node_fs4.default.mkdirSync(lock);
+      import_node_fs7.default.mkdirSync(lock);
       return true;
     } catch {
     }
     try {
-      if (Date.now() - import_node_fs4.default.statSync(lock).mtimeMs > 6e4) {
-        import_node_fs4.default.rmdirSync(lock);
+      if (Date.now() - import_node_fs7.default.statSync(lock).mtimeMs > 6e4) {
+        import_node_fs7.default.rmdirSync(lock);
         continue;
       }
     } catch {
@@ -350,13 +490,13 @@ function registerOwner(paths) {
   const owner = ownerPid();
   if (owner) owners.add(owner);
   const tmp = `${paths.owners}.${process.pid}`;
-  import_node_fs4.default.writeFileSync(tmp, [...owners].sort((a, b) => a - b).map((pid) => `${pid}
+  import_node_fs7.default.writeFileSync(tmp, [...owners].sort((a, b) => a - b).map((pid) => `${pid}
 `).join(""));
-  import_node_fs4.default.renameSync(tmp, paths.owners);
+  import_node_fs7.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_fs4.default.writeFileSync(paths.agent, `${JSON.stringify(markers)}
+  if (Object.keys(markers).length) import_node_fs7.default.writeFileSync(paths.agent, `${JSON.stringify(markers)}
 `);
 }
 async function replace(pid, paths) {
@@ -388,9 +528,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_fs4.default.mkdirSync(paths.state, { recursive: true });
-  if (!import_node_fs4.default.existsSync(import_node_path2.default.join(paths.state, ".gitignore"))) import_node_fs4.default.writeFileSync(import_node_path2.default.join(paths.state, ".gitignore"), "*\n");
-  const server = import_node_path2.default.join(__dirname, "server.cjs");
+  import_node_fs7.default.mkdirSync(paths.state, { recursive: true });
+  if (!import_node_fs7.default.existsSync(import_node_path7.default.join(paths.state, ".gitignore"))) import_node_fs7.default.writeFileSync(import_node_path7.default.join(paths.state, ".gitignore"), "*\n");
+  const server = import_node_path7.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;
@@ -398,7 +538,7 @@ async function start(options, emit) {
     if (!locked) return;
     locked = false;
     try {
-      import_node_fs4.default.rmdirSync(paths.lock);
+      import_node_fs7.default.rmdirSync(paths.lock);
     } catch {
     }
   };
@@ -416,17 +556,17 @@ async function start(options, emit) {
     }
     registerOwner(paths);
     recordAgent(paths);
-    import_node_fs4.default.rmSync(paths.info, { force: true });
+    import_node_fs7.default.rmSync(paths.info, { force: true });
     const id = import_node_crypto.default.randomBytes(24).toString("hex");
-    import_node_fs4.default.writeFileSync(paths.serverId, `${id}
+    import_node_fs7.default.writeFileSync(paths.serverId, `${id}
 `);
-    import_node_fs4.default.writeFileSync(paths.version, `${version}
+    import_node_fs7.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_fs4.default.writeFileSync(paths.pid, `${child2.pid}
+      import_node_fs7.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) => {
@@ -441,15 +581,15 @@ async function start(options, emit) {
         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_fs4.default.existsSync(paths.info); waited += 100) await sleep(100);
+      for (let waited = 0; waited < 5e3 && !import_node_fs7.default.existsSync(paths.info); waited += 100) await sleep(100);
       unlock();
       return await exited;
     }
-    const log = import_node_fs4.default.openSync(paths.log, "w");
+    const log = import_node_fs7.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_fs4.default.closeSync(log);
+    import_node_fs7.default.closeSync(log);
     child.unref();
-    import_node_fs4.default.writeFileSync(paths.pid, `${child.pid}
+    import_node_fs7.default.writeFileSync(paths.pid, `${child.pid}
 `);
     for (let waited = 0; waited < 5e3; waited += 100) {
       const lines = (readText(paths.log) ?? "").split("\n");
@@ -509,13 +649,13 @@ async function publish(options, emit) {
 }
 
 // src/cli/stop.ts
-var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 async function stop(projectDir, emit) {
   const paths = projectPaths(projectDir);
   const markStopped = (reason) => {
-    import_node_fs5.default.rmSync(paths.info, { force: true });
-    import_node_fs5.default.mkdirSync(paths.state, { recursive: true });
-    import_node_fs5.default.writeFileSync(paths.stopped, `${JSON.stringify({ reason, timestamp: Math.floor(Date.now() / 1e3) })}
+    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));
@@ -525,8 +665,8 @@ async function stop(projectDir, emit) {
   }
   const id = readText(paths.serverId) ?? "";
   if (!Number.isInteger(pid) || pid <= 0 || !/^[A-Za-z0-9_-]{32,64}$/.test(id) || !hasServerId(pid, id)) {
-    import_node_fs5.default.rmSync(paths.pid, { force: true });
-    import_node_fs5.default.rmSync(paths.serverId, { force: true });
+    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;
@@ -546,7 +686,7 @@ async function stop(projectDir, emit) {
     emit({ status: "failed", error: "process still running" });
     return 1;
   }
-  for (const file of [paths.pid, paths.serverId, paths.log, paths.owners]) import_node_fs5.default.rmSync(file, { force: true });
+  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;
@@ -571,6 +711,10 @@ Commands:
               reply   --artifact document/<id> --thread <threadId> [--text <text>]
               resolve --artifact document/<id> --thread <threadId>
             Without --text, add and reply read the message from stdin.
+  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)
@@ -596,6 +740,7 @@ function text(value) {
   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 commented = commentText(value);
   if (commented !== null) return commented;
   if (typeof value.status === "string") return value.status === "stopped" ? "Stopped." : value.status.replace(/_/g, " ");
@@ -706,8 +851,16 @@ async function main(argv) {
         text: values.text
       }, emit);
     }
+    if (command === "config") {
+      const { values } = parse(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 === "--version" || command === "-v") {
-      console.log("1.11.0");
+      console.log("1.12.0");
       return 0;
     }
     if (command === "--help" || command === "-h") {