@minnovate/shadow-publisher 0.9.1 → 0.10.0

package/dist/claude/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "git-publisher",
   "displayName": "Git Publisher",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Publish an app folder's Git history to the serverless Git publishing backend and keep it updated (\"publish my app\", \"update my app\", \"fetch the engineered version\").",
   "author": { "name": "git-publisher project" },
   "keywords": ["git", "publish", "deploy", "serverless"]

package/dist/claude/plugin/skills/publish-app/SKILL.md

@@ -63,6 +63,12 @@ Then read the log every few seconds until it holds a JSON object (`ok: true`), f
 In a Claude Cowork task this happens again in every new task, because the sandbox forgets the
 sign-in when the task ends.
 
+**If a tool named `approve_publisher_sign_in` is available** (the Shadow publisher connector, which
+the person connected in Claude's settings), do not give them the link: call that tool with the code
+from the log, then keep reading the log as above — it reaches `ok: true` within a few seconds, with
+nothing for the person to do. If the tool answers that it did not approve, give them the link and
+code as above. The tool never returns a credential, and you never need one.
+
 **Never ask the user for a token, an endpoint, a URL or a credential — in any words.** They are
 publishing an app; they do not know what those are, and you do not need them: `login` discovers
 where publishing lives and signs them in through their browser. `next.ask` is `null` whenever
@@ -93,6 +99,12 @@ That one command records what changed in the folder, brings in anything publishe
 fast-forward or a clean merge — it never rewrites the user's work), and publishes the result. Write
 the message in the user's words ("Add a contact page"), not git's.
 
+A published app runs with no internet access: **it may not load anything from other sites** — no
+CDN scripts, web fonts or remote images. When you write or change an app, keep every file it needs
+in its folder. The checks refuse an app that does not (see "When the checks find something").
+Keep it small too: each file at most 200 KB, the whole app at most 500 KB, fewer than 100 files —
+a larger app is refused before it is checked, with no findings to say why.
+
 ## 4. Telling them how it goes, step by step
 
 After a publish, the app goes through four steps: **received**, **checked**, **going live**,
@@ -123,9 +135,10 @@ following, for when the person asks not to wait.
   `recorded.excluded` is not empty, what was left out and why. Then read `progress` (null with
   `--no-wait`) and pass on its `hint`:
   - `kind: "settled"` with `ending` `"live"`: the app is live. `"not-deployed"`: published and
-    checked, and this organisation does not deploy automatically. `"failed"`: it stopped at
-    `failedAt`; the portal says why — do not guess the reason. `"stopped"`: a newer publication
-    replaced it.
+    checked, and this organisation does not deploy automatically. `"failed"` with `findings`: it
+    did not pass its checks, and `findings` says why — fix them as "When the checks find something"
+    below says. `"failed"` without `findings`: it stopped at `failedAt`; the portal says why — do
+    not guess the reason. `"stopped"`: a newer publication replaced it.
   - `"moving"` or `"timed-out"`: still going; follow it as step 4 says. After about 15 minutes in
     all, stop and point them to the portal (`progress.portal`).
   - `"unauthorized"`: published, but the portal did not accept this sign-in; run `publisher login`
@@ -152,6 +165,35 @@ following, for when the person asks not to wait.
 - Exit code 4: run `publisher doctor --json` and follow `next.action` (normally `reauthenticate`:
   run `next.command`). Never ask the user for a token.
 
+
+### When the checks find something
+
+Before an app goes live the platform opens it in a browser, with no internet access, and checks
+it loads cleanly. When it does not, `progress.findings` lists what it found, each with a `fix`
+sentence, and `progress.next.action` is `"fix"`. Then:
+
+1. Tell the person in one sentence that the app did not pass its checks and that you will fix it.
+   Their original app is still what is published; nothing broke.
+2. Fix every finding in the app folder, by its `kind`:
+   - `external-resource`: the app loads `url` from another site (a CDN script, Google Fonts, an
+     image). **Apps may not load anything from other sites.** Download the file into the app
+     folder and point to it with a relative path — only if it is at most 200 KB; a charting
+     library usually is not (Chart.js is 201 KB). Otherwise replace it with code of your own: a
+     font falls back to a system font stack, a chart is drawn as inline SVG. Never keep the
+     external address.
+   - `console-error` / `application-error`: fix the code that logs or throws `message`.
+   - `failed-request`: the app asks for `path` on its own site and gets `status`; add the file or
+     stop requesting it.
+   - `missing-request`: the app never loaded its company data from `path`; make it read from there.
+   - `missing-text` / `page-load`: the page did not show its results, or did not finish loading
+     (for example a `fetch` whose response is never read); make it render without waiting.
+3. Run `progress.next.command` (it is `publisher sync <folder> --until-change --json`) and follow
+   the new publication as step 4 says. Fix and publish again at most twice for the same findings;
+   if they come back a third time, stop and tell the person what is still found.
+
+Never tell the person a finding's `url` or `message` is a secret or their data — the platform has
+already removed both. Do not invent findings that are not in the list.
+
 ## 5. A folder that starts empty
 
 On a new computer, or in a Claude Cowork task (whose sandbox starts empty every time), the app the

package/dist/publisher.cjs

@@ -4747,7 +4747,10 @@ async function followRun(input, opts) {
         }
         if (isRecord2(run.run) && run.run["status"] === "awaiting-approval") return { kind: "waiting", stages: read2.stages };
         const end = ending(read2.stages);
-        if (end !== null) return { kind: "settled", ending: end, failedAt: read2.stages.find((s) => s.state === "failed")?.word ?? null, stages: read2.stages };
+        if (end !== null) {
+          const runId = isRecord2(run.run) && typeof run.run["runId"] === "string" ? run.run["runId"] : null;
+          return { kind: "settled", ending: end, failedAt: read2.stages.find((s) => s.state === "failed")?.word ?? null, stages: read2.stages, runId };
+        }
         if (opts.untilChange === true && moved && answered) return { kind: "moving", stages: read2.stages };
       }
       answered = true;
@@ -4812,6 +4815,8 @@ function isRecord2(value) {
 // ../client/src/preparation.ts
 var PREPARATION = "preparation";
 var STATUSES = ["queued", "running", "needs-choice", "ready", "blocked", "cancelled"];
+var MAX_FINDINGS = 10;
+var MAX_TEXT = 500;
 function readPreparation(input, opts) {
   return call(input, opts, void 0);
 }
@@ -4866,7 +4871,27 @@ function readView(body) {
   if (isRecord3(publication) && typeof publication["status"] === "string" && typeof publication["message"] === "string") {
     pub = { status: publication["status"], message: publication["message"], ...typeof publication["url"] === "string" ? { url: publication["url"] } : {} };
   }
-  return { id, revision, status, message, questions: read2, publication: pub };
+  return { id, revision, status, message, questions: read2, publication: pub, findings: readFindings(body["findings"]) };
+}
+function readFindings(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  const text = (v) => typeof v === "string" && v !== "" ? v.slice(0, MAX_TEXT) : void 0;
+  for (const f of value) {
+    if (out.length === MAX_FINDINGS) break;
+    if (!isRecord3(f)) continue;
+    const kind = text(f["kind"]);
+    const fix = text(f["fix"]);
+    if (kind === void 0 || fix === void 0) continue;
+    const finding = { kind, fix };
+    for (const field of ["url", "path", "message"]) {
+      const value2 = text(f[field]);
+      if (value2 !== void 0) finding[field] = value2;
+    }
+    if (typeof f["status"] === "number" && Number.isInteger(f["status"])) finding.status = f["status"];
+    out.push(finding);
+  }
+  return out;
 }
 async function ask2(fetchImpl, url2, token, body) {
   try {
@@ -5908,8 +5933,29 @@ async function followPublication(p, endpoint, o, opts) {
   const answerable = confirmed.terminal.includes(PREPARATION);
   const dir = shellWord(opts.dir);
   const next = outcome.kind === "timed-out" || outcome.kind === "moving" ? { action: "follow", command: `publisher follow ${dir} --publication ${o.publicationId}${opts.untilChange === true ? " --until-change" : ""} --json` } : outcome.kind === "waiting" && answerable ? { action: "question", command: `publisher question ${dir} --json` } : void 0;
+  const findings = await failedChecks(p, portal, o.repoId, outcome, answerable);
+  if (findings !== null) {
+    return {
+      ...outcome,
+      portal,
+      hint: `It did not pass its checks (${findings.length === 1 ? "one finding" : `${findings.length} findings`}). Fix each finding in the app folder, then run next.command to publish again.`,
+      findings,
+      next: { action: "fix", command: `publisher sync ${dir} --until-change --json` }
+    };
+  }
   return { ...outcome, portal, hint: progressHint(outcome, portal, answerable), ...next === void 0 ? {} : { next } };
 }
+async function failedChecks(p, portal, repoId, outcome, served) {
+  if (!served || outcome.kind !== "settled" || outcome.ending !== "failed" || outcome.runId === null) return null;
+  if (outcome.stages.find((s) => s.state === "failed")?.stage !== "running") return null;
+  try {
+    const answer = await p.readPreparation({ portal, repoId });
+    if (answer.kind !== "view" || answer.view.id !== outcome.runId || answer.view.status !== "blocked") return null;
+    return answer.view.findings.length === 0 ? null : answer.view.findings;
+  } catch {
+    return null;
+  }
+}
 function followTimeoutMs(flag) {
   if (flag === void 0) return FOLLOW_TIMEOUT_MS;
   if (!/^[1-9][0-9]*$/.test(flag)) throw new PublisherError("INVALID_REQUEST", `--timeout takes a whole number of seconds, not ${JSON.stringify(flag)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnovate/shadow-publisher",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "publisher: publish an app's Git history to the serverless Git backend",
   "license": "Apache-2.0",
   "type": "module",