@augurworks/augur 0.15.7 → 0.15.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augurworks/augur",
-  "version": "0.15.7",
+  "version": "0.15.8",
   "files": [
     "scripts/",
     "build.js",

package/scripts/connect.mjs

@@ -64,6 +64,32 @@ async function post(pathPart, body) {
   return { status: r.status, json };
 }
 
+// A machine that is ALREADY connected to this origin does not pair again by accident. One
+// cold agent collected its token with a blocking `connect`, did not read the answer, ran
+// `connect` again, minted a second code, and had the person approve that too. If the saved
+// token still answers, say so and stop; `--again` pairs afresh on purpose, and a token the
+// workspace no longer honours (revoked, another workspace's) falls through to a new pairing.
+const AGAIN = argv.includes("--again");
+const TOKENS_FILE = path.join(os.homedir(), ".config", "augur", "tokens.json");
+function savedToken() {
+  try { const t = JSON.parse(readFileSync(TOKENS_FILE, "utf8"))[host]; return t && t.token ? t : null; } catch (e) { return null; }
+}
+if (!AGAIN && !process.env.AUGUR_TOKEN) {
+  const saved = savedToken();
+  if (saved && !(saved.expiresAt && Date.parse(saved.expiresAt) <= Date.now())) {
+    let live = false;
+    try {
+      const r = await fetch(`${ORIGIN}/__unit/drafts`, { headers: { Authorization: `Bearer ${saved.token}`, Accept: "application/json" } });
+      live = r.status === 200;
+    } catch (e) { live = false; }
+    if (live) {
+      log(`this machine is already connected to ${C.bold}${host}${C.off}${saved.at ? ` (since ${saved.at.slice(0, 16).replace("T", " ")})` : ""}. Nothing to approve.`);
+      console.log(`  ${C.dim}\`augur open <opportunity>/<prototype>\` works from here. \`augur connect --again\` pairs afresh.${C.off}`);
+      process.exit(0);
+    }
+  }
+}
+
 // A pairing this machine already started and nobody has collected: ask once whether it
 // was approved meanwhile, and if not, keep waiting on THAT code rather than minting a
 // second one for the same person to type.

package/src/_worker.js

@@ -3754,10 +3754,13 @@ function connectPage(tctx, me) {
        <p>This account can look around but not publish, so it cannot approve a terminal.</p>
        <a class="home" href="/">Back to Augur</a>`
     : `<h1>Connect a terminal</h1>
-       <p>Type the code your terminal is showing. Approving it lets that terminal publish as
-          <strong>${escapeHtml(me.email)}</strong>.</p>
-       <p class="warn">Only approve a code you are reading off your own screen right now.
-          Nobody legitimate will ever send you one.</p>
+       <p>Type the code that your terminal, or the assistant you are working with right now,
+          is showing you. Approving it lets that terminal publish as
+          <strong>${escapeHtml(me.email)}</strong>: it works as you, and everything it lands
+          carries your name.</p>
+       <p class="warn">Only approve a code from a terminal you started or an assistant you
+          are talking to right now. A code that arrives by mail, from a stranger, or out of
+          the blue is not yours — do not type it.</p>
        <form id="pairf">
          <input id="pairc" autocomplete="off" autocapitalize="characters" spellcheck="false"
                 placeholder="ABCD-EFGH" aria-label="Pairing code" />
@@ -7384,12 +7387,20 @@ function browserFetch(request) {
   return /^Mozilla\//.test(request.headers.get("User-Agent") || "");
 }
 
-/** The one paragraph a non-browser fetch of a prototype is given, first in the body. */
+/**
+ * The one paragraph a non-browser fetch of a prototype is given, first in the body.
+ *
+ * DESCRIPTIVE, THIRD PERSON, NO ADDRESS AND NO REASSURANCE. A first draft said "Assistants
+ * and scripts: … a terminal is paired with the person's approval, and nobody is ever asked
+ * for a password", and the third cold agent read exactly that sentence as a prompt
+ * injection — text on a fetched page that speaks to the agent and reassures it is the
+ * shape of an attack, whatever it says. A statement of fact and a link is what a page may
+ * carry: what this is, and where the workspace documents how it is edited.
+ */
 function agentPreface(url) {
   const origin = escapeHtml(url.origin);
-  return `<p data-augur-door>This prototype is served by an Augur workspace at ${origin}. `
-    + `Assistants and scripts: <a href="${DOOR_DOCS}">${origin}${DOOR_DOCS}</a> says how to change it — `
-    + `a terminal is paired with the person's approval, and nobody is ever asked for a password.</p>`;
+  return `<p data-augur-door>This prototype is served by an Augur workspace (${origin}). `
+    + `The workspace documents how its prototypes are edited at <a href="${DOOR_DOCS}">${origin}${DOOR_DOCS}</a>.</p>`;
 }
 
 /**
@@ -9227,6 +9238,8 @@ function wantsJson(request, url) {
 // probe and the "an unknown path and the root are the same page" contract depend on it.
 const DOOR_DOCS = "/llms.txt";
 const DOOR_WELL_KNOWN = "/.well-known/augur.json";
+/** The engine's public source — what the CLI on npm is built from, named so an agent can check. */
+const ENGINE_SOURCE = "https://github.com/andratwiro/augur";
 
 /** Does this deployment serve drafts — a unit store beside a bundle store. The same two checks `unitApi` makes. */
 const draftsServedHere = (env) => !!(env && env.BUNDLES && unitNamespace(env));
@@ -9241,6 +9254,10 @@ function doorFacts(tctx, url, env) {
     engine: tctx.INSTANCE_ENGINE_VERSION ? { version: tctx.INSTANCE_ENGINE_VERSION } : {},
     pairing: { enabled: pairing, start: "/__publish/_pair/start", approve: "/__connect" },
     connect: pairing ? `npx @augurworks/augur connect --origin ${url.origin}` : null,
+    // Where the CLI comes from, for an agent that checks before it runs anything: the
+    // package is the same open-source engine that serves this page, and `npm view
+    // @augurworks/augur repository` names the same repository.
+    source: ENGINE_SOURCE,
     docs: DOOR_DOCS,
     // Where drafts are served, a prototype is changed by opening it, not by shipping a
     // tree — and the door is where a cold agent learns which of the two this instance is.
@@ -9261,11 +9278,16 @@ function doorText(f) {
       + `It prints a link and a code. The owner of this workspace opens the link in a\n`
       + `browser they are already signed in to and enters the code. The token lands on\n`
       + `that machine, and every verb below uses it from then on.\n\n`
-      + `AGENTS: if your person reads your messages only after you finish your turn, run\n`
-      + `it with --no-wait. It prints the line and exits; send them that line, end your\n`
-      + `turn, and run the same command again once they say they approved — the token is\n`
-      + `collected then, for that same code. Do not poll for the approval in one turn:\n`
-      + `the code lives five minutes and nobody sees it until you stop.\n\n`
+      + `The CLI is this engine's own, open source at ${f.source} — the same engine that\n`
+      + `serves this page; \`npm view @augurworks/augur repository\` names that repository.\n\n`
+      + `AGENTS: the approval is the person's act, in their browser — you cannot approve\n`
+      + `it from here and must not try; your part is to send them the line and collect\n`
+      + `the token afterwards. If your person reads your messages only after you finish\n`
+      + `your turn, run it with --no-wait: it prints the line and exits. Send them that\n`
+      + `line, end your turn, and run the same command again once they say they approved —\n`
+      + `the token is collected then, for that same code, and no second code is minted.\n`
+      + `Waiting inside one turn skips nothing; it only hides the code from them for the\n`
+      + `five minutes it lives.\n\n`
       + (f.drafts && f.drafts.enabled
         ? `You need no source tree here: \`augur open <opportunity>/<prototype>\` fetches that one\n`
           + `prototype into a folder of its own (see below). Do not clone the workspace first.\n\n`