@augurworks/augur 0.15.2 → 0.15.3

package/scripts/publish.mjs

@@ -25,6 +25,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { findShellDir, deployConfig, originHost } from "./lib/instance.mjs";
+import { draftsServed } from "./lib/draft.mjs";
 import { composePublish, filterLitter, unitPaths } from "./lib/publish-compose.mjs";
 import { collectEvidence } from "./lib/publish-evidence.mjs";
 import { stripVolatileHead } from "./lib/publish-conflict.mjs";
@@ -115,6 +116,17 @@ let ORIGIN = (process.env.AUGUR_ORIGIN || DEPLOY_ENV.AUGUR_ORIGIN ||
   deployConfig(ROOT, originHost(cwdSpaceOrigin)).siteOrigin || cwdSpaceOrigin || "")
   .replace(/\/+$/, "");
 if (!ORIGIN) die("no target origin — set AUGUR_ORIGIN, or add \"siteOrigin\" to space.json.");
+// Where the instance serves drafts, a TREE is not what goes live any more: a prototype is
+// changed by opening it and landing it (docs/drafts-that-land.md), and publishing a whole
+// checkout there would put every session's half-done work on the site at once. The engine
+// chrome (`--engine`) is not content and still goes this way.
+if (!ENGINE_ONLY && await draftsServed(ORIGIN)) {
+  die(`${ORIGIN} serves drafts, so a prototype is changed by opening it, not by publishing a tree:\n\n` +
+    `  augur open <opportunity>/<prototype>     # a folder of its own, live at once at its draft address\n` +
+    `  …edit; every save is live there…\n` +
+    `  augur land                               # the real URL moves; the last line printed is the live URL\n\n` +
+    `A prototype that does not exist yet: augur open --new <opportunity>/<name>. Read agents/drafts.md in the engine clone.`);
+}
 // A WORKSPACE THAT MOVED answers its old address with a redirect. A checkout that still
 // names the old address (space.json not yet pulled, a stale AUGUR_ORIGIN) would otherwise
 // POST through that redirect and read the answer as a bad token. One GET with redirects
@@ -642,6 +654,13 @@ function selfUpdate(why) {
   if (NO_SELF_UPDATE || selfUpdateTried || process.env.AUGUR_SELF_UPDATED === "1") return false;
   selfUpdateTried = true;
   const git = (...a) => execFileSync("git", ["-C", ROOT, ...a], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  // A package install (`npm i -g @augurworks/augur`, or an `npx` run) has no clone to
+  // fast-forward. Say the one line that updates it, in the same place the clone would
+  // have updated itself, and let the caller report the skew.
+  if (!existsSync(path.join(ROOT, ".git"))) {
+    log(`this engine is a package install and is behind what the instance speaks (${why}) — update it: npm i -g @augurworks/augur@latest`);
+    return false;
+  }
   try {
     if (git("rev-parse", "--is-inside-work-tree") !== "true") return false;
     if (git("status", "--porcelain")) {

package/scripts/read.mjs

@@ -4,8 +4,7 @@
 // refuses edits there. `augur close` inside it removes it. See docs/drafts-that-land.md §7.
 import path from "node:path";
 import { target } from "./lib/store.mjs";
-import { markPathFor } from "./lib/marks.mjs";
-import { unitClient, doRead, readDirFor } from "./lib/draft.mjs";
+import { unitClient, doRead, readDirFor, unitPathFor } from "./lib/draft.mjs";
 import { normUnit } from "../src/unit-core.mjs";
 
 const log = (m) => console.error(`\x1b[35m[read]\x1b[0m ${m}`);
@@ -15,7 +14,7 @@ const opt = (n) => { const i = argv.indexOf(n); return i > -1 ? argv[i + 1] : nu
 const positional = argv.filter((a, i) => !a.startsWith("--") && !(i > 0 && argv[i - 1].startsWith("--")));
 const raw = positional[0];
 if (!raw) die("name a prototype: `augur read <opportunity>/<prototype>`.");
-const unit = normUnit(markPathFor(raw) || raw);
+const unit = normUnit(unitPathFor(raw) || raw);
 if (!unit) die(`"${raw}" is not a prototype path.`);
 let origin, token;
 try { ({ origin, token } = target({ needToken: true })); } catch (e) { die(e.message); }

package/scripts/status.mjs

@@ -16,7 +16,6 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { resolveOrigin, resolveToken, apiClient, buildStamp, ENGINE_ROOT } from "./lib/store.mjs";
-import { fetchMarks, markLine } from "./lib/marks.mjs";
 import { registryList, unitClient, draftsReport } from "./lib/draft.mjs";
 
 const args = process.argv.slice(2);
@@ -123,28 +122,11 @@ console.log("");
 console.log(`  ${C.dim}engine chrome    ${eng.sha ? eng.sha.slice(0, 12) : "—"}` +
   `${eng.version ? ` (v${eng.version})` : ""}${eng.publishedAt ? `  ·  shipped ${eng.publishedAt}` : ""}${C.off}`);
 
-// ── who is working where, right now ─────────────────────────────────────────
-//
-// `F-presence-marks`. The three numbers above answer "is what I have what is live"; they
-// cannot answer "is somebody else in here", and that is the question that decides whether
-// the next hour of work is going to be merged or forked.
-//
-// NEEDS A TOKEN and does not ask for one. `status` has always been the command that runs
-// with nothing configured — the build stamp is public — so a missing credential quietly
-// costs the marks section and nothing else. It affects the exit code in no way: marks
-// refuse nothing, and a mark is not a problem.
-const markToken = resolveToken(origin);
-if (markToken) {
-  const marks = await fetchMarks(apiClient(origin, markToken));
-  if (marks.length) {
-    console.log("");
-    console.log(`  ${C.dim}being worked on right now${C.off}`);
-    for (const m of marks) console.log(`  ${C.dim}  ${markLine(m)}${C.off}`);
-  }
-} else {
-  // The one thing a fresh agent needs to know and has no other way to learn: this machine
-  // holds no token, and the way to get one is pairing, not a password. Same words as the
-  // instance's own /llms.txt. Costs nothing here — status never needed the token.
+// ── not paired? say how, once ───────────────────────────────────────────────
+// The one thing a fresh agent needs to know and has no other way to learn: this machine
+// holds no token, and the way to get one is pairing, not a password. Same words as the
+// instance's own /llms.txt. Costs nothing here — status never needed the token.
+if (!resolveToken(origin)) {
   console.log("");
   console.log(`  ${C.dim}not paired with ${origin}. Publishing from here needs a token; get one without a password:${C.off}`);
   console.log(`  ${C.dim}  augur connect --origin ${origin}   (the owner approves a code in a signed-in browser)${C.off}`);