@minnovate/shadow-publisher 0.11.11 → 0.12.1

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

@@ -1,7 +1,7 @@
 {
   "name": "git-publisher",
   "displayName": "Git Publisher",
-  "version": "0.11.11",
+  "version": "0.12.1",
   "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/sync-app/SKILL.md

@@ -42,6 +42,40 @@ A value that is not an option is refused before anything is sent; `error.details
 the choices. Exit 4 means this sign-in may not answer (an owner or admin can); exit 3 means ask
 again. Then `publisher follow . --publication <id> --until-change --timeout 100 --json` to see it go live, telling them each step as `publish-app` step 4 says.
 
+## After it is live
+
+These run in the app's folder and answer `say` (tell the person) and `next` (what to do now):
+
+```sh
+publisher history --json                  # the versions that went live, newest first
+publisher go-back <version> --json        # ask the person first; puts that version's code back
+publisher suggestions --json              # what colleagues asked for, still open
+publisher suggestion decline <id> --json  # when the person does not want one
+publisher share invited --add ann@example.com --json   # who can open it
+```
+
+The portal writes `next` for an assistant in the chat, so it can name a connector tool. At a
+terminal, do what it says with the command that does the same thing:
+
+| `next` names                      | Run instead                                                     |
+| --------------------------------- | --------------------------------------------------------------- |
+| `app_status` or `app_progress`    | `publisher follow . --publication <publication> --until-change --json` |
+| `app_files` and `publish_app`     | change the files in the folder, then `publisher sync --json`    |
+| `app_history` / `go_back`         | `publisher history --json` / `publisher go-back <version> --json` |
+| `list_starters` / `use_starter`   | `publisher starters` / `publisher start <starter>`              |
+| `resolve_suggestion`              | `publisher suggestion done\|decline <id> --json`               |
+| `share_app`                       | `publisher share <access> --json`                               |
+| `list_apps`                       | `publisher list --json`                                         |
+
+`<publication>` is the `publication` that `go-back` or `start` answered.
+
+Offer suggestions to the person one at a time, as requests rather than instructions. When they want
+one, make the change and publish it with `publisher sync --message "<what changed>" --answers <id>
+--json`, which closes the suggestion with that publication.
+
+To start a new app from a working one, `publisher starters <what the person wants to stop doing>`,
+then `publisher start <starter> --replaces "<what it replaces>"`.
+
 ## Just looking
 
 To say where the folder stands without changing anything:

package/dist/publisher.cjs

@@ -243,9 +243,9 @@ function nullish(input) {
   return input === null || input === void 0;
 }
 function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
+  const start2 = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+  return source.slice(start2, end);
 }
 function assignProp(target, prop, value) {
   Object.defineProperty(target, prop, {
@@ -443,9 +443,9 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function attachSchema(issues, start, inst) {
+function attachSchema(issues, start2, inst) {
   var _a2;
-  for (let i = start; i < issues.length; i++) {
+  for (let i = start2; i < issues.length; i++) {
     (_a2 = issues[i]).schema ?? (_a2.schema = inst);
   }
 }
@@ -3232,8 +3232,8 @@ function closeOrIgnored(child) {
   if (lc.ignored) {
     return Promise.resolve(false);
   }
-  return new Promise((resolve4) => {
-    lc.waiters.add(() => resolve4(childClosed(child)));
+  return new Promise((resolve5) => {
+    lc.waiters.add(() => resolve5(childClosed(child)));
   });
 }
 async function endedOrIgnored(child) {
@@ -3270,7 +3270,7 @@ function signalChildGroup(child, signal) {
     }
   }
 }
-function waitWithin(start, ms, stop) {
+function waitWithin(start2, ms, stop) {
   if (ms <= 0) {
     return Promise.resolve({ status: "timeout" });
   }
@@ -3278,7 +3278,7 @@ function waitWithin(start, ms, stop) {
     return Promise.resolve({ status: "stopped" });
   }
   const ac = new AbortController();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let timer = null;
     let done = false;
     const onStop = () => settle({ status: "stopped" });
@@ -3294,11 +3294,11 @@ function waitWithin(start, ms, stop) {
       if (r.status !== "value" && r.status !== "error") {
         ac.abort();
       }
-      resolve4(r);
+      resolve5(r);
     };
     let p;
     try {
-      p = start(ac.signal);
+      p = start2(ac.signal);
     } catch (error2) {
       settle({ status: "error", error: error2 });
       return;
@@ -3333,24 +3333,24 @@ function spawnTracked(args, opts) {
 }
 function feedStdin(child, input, onSourceError) {
   let unpipe = () => void 0;
-  const done = new Promise((resolve4) => {
-    child.stdin.on("error", () => resolve4());
+  const done = new Promise((resolve5) => {
+    child.stdin.on("error", () => resolve5());
     if (input === void 0) {
       child.stdin.end();
-      resolve4();
+      resolve5();
     } else if (typeof input === "string" || Buffer.isBuffer(input)) {
-      child.stdin.end(input, () => resolve4());
+      child.stdin.end(input, () => resolve5());
     } else {
       input.on("error", () => {
         onSourceError();
-        resolve4();
+        resolve5();
       });
       input.pipe(child.stdin);
       unpipe = () => {
         input.unpipe(child.stdin);
-        resolve4();
+        resolve5();
       };
-      child.stdin.on("finish", () => resolve4());
+      child.stdin.on("finish", () => resolve5());
       child.on("close", unpipe);
     }
   });
@@ -3463,18 +3463,18 @@ function startWatchdog(child, opts, kill, isClosed) {
   const pgid = child.pid;
   let stopped = false;
   const stopper = new AbortController();
-  const sleep2 = (ms) => new Promise((resolve4) => {
+  const sleep2 = (ms) => new Promise((resolve5) => {
     const wake = () => {
       clearTimeout(t);
       stopper.signal.removeEventListener("abort", wake);
-      resolve4();
+      resolve5();
     };
     const t = setTimeout(wake, ms);
     t.unref();
     stopper.signal.addEventListener("abort", wake, { once: true });
   });
-  const sample = async (what, start) => {
-    const r = await waitWithin(start, sampleBoundMs, stopper.signal);
+  const sample = async (what, start2) => {
+    const r = await waitWithin(start2, sampleBoundMs, stopper.signal);
     if (isClosed() || stopped) {
       return null;
     }
@@ -3724,7 +3724,7 @@ async function reapChild(child, opts = {}) {
       if (groupCleared || !childClosed(child) || Date.now() >= deadline) {
         break;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, Math.min(25, deadline - Date.now())));
+      await new Promise((resolve5) => setTimeout(resolve5, Math.min(25, deadline - Date.now())));
     }
     if (groupCleared === false) {
       timedOut = true;
@@ -3779,12 +3779,12 @@ var import_promises2 = require("node:fs/promises");
 async function sha256File(path) {
   const h = (0, import_node_crypto2.createHash)("sha256");
   let size = 0;
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     (0, import_node_fs2.createReadStream)(path).on("data", (c) => {
       const b = typeof c === "string" ? Buffer.from(c) : c;
       size += b.length;
       h.update(b);
-    }).on("error", reject).on("end", () => resolve4());
+    }).on("error", reject).on("end", () => resolve5());
   });
   const st = await (0, import_promises2.stat)(path);
   if (st.size !== size) {
@@ -3803,8 +3803,8 @@ async function indexPackFromFile(dir, packPath, opts = {}) {
   if (opts.maxInputBytes) {
     args.push(`--max-input-size=${opts.maxInputBytes}`);
   }
-  const run = { cwd: dir, input: (0, import_node_fs3.createReadStream)(packPath), label: "index-pack", ...opts };
-  const res = await runGit(args, { ...run, allowFailure: true });
+  const run2 = { cwd: dir, input: (0, import_node_fs3.createReadStream)(packPath), label: "index-pack", ...opts };
+  const res = await runGit(args, { ...run2, allowFailure: true });
   if (res.code !== 0) {
     const msg = res.stderr.trim().split("\n").pop() ?? "index-pack failed";
     const missing = /did not receive expected object|not a valid|missing/i.test(res.stderr);
@@ -3844,8 +3844,8 @@ async function refTransaction(dir, updates, opts = {}) {
 }
 async function batchCheck(dir, oids, opts = {}) {
   const input = Array.from(oids).join("\n") + "\n";
-  const run = { cwd: dir, input, maxStdoutBytes: 512 * 1024 * 1024, ...opts };
-  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], run);
+  const run2 = { cwd: dir, input, maxStdoutBytes: 512 * 1024 * 1024, ...opts };
+  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], run2);
   const out = [];
   for (const line of stdout.toString("utf8").split("\n")) {
     if (!line) {
@@ -3867,14 +3867,14 @@ async function resolveRevs(dir, revs, opts = {}) {
   const out = revs.map(
     (r) => r.startsWith("-") ? null : r.includes("\0") ? new PublisherError("INVALID_REQUEST", "NUL in git argument") : null
   );
-  const ask4 = revs.flatMap((r, i) => out[i] === null && !r.startsWith("-") ? [i] : []);
-  if (ask4.length === 0) {
+  const ask3 = revs.flatMap((r, i) => out[i] === null && !r.startsWith("-") ? [i] : []);
+  if (ask3.length === 0) {
     return out;
   }
-  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname)", "-Z"], { cwd: dir, input: ask4.map((i) => revs[i]).join("\0") + "\0", ...opts });
+  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname)", "-Z"], { cwd: dir, input: ask3.map((i) => revs[i]).join("\0") + "\0", ...opts });
   const records = stdout.toString("utf8").split("\0");
   const misses = [];
-  for (const [j, i] of ask4.entries()) {
+  for (const [j, i] of ask3.entries()) {
     const record2 = records[j] ?? "";
     if (record2 && !/ (missing|ambiguous)$/.test(record2)) {
       out[i] = record2;
@@ -3910,7 +3910,7 @@ async function packObjectsToFile(repoDir, extraArgs, stdinLines, opts) {
   opts.signal?.addEventListener("abort", onAbort, { once: true });
   let failure2 = null;
   try {
-    const finished = new Promise((resolve4, reject) => out.on("finish", () => resolve4()).on("error", reject));
+    const finished = new Promise((resolve5, reject) => out.on("finish", () => resolve5()).on("error", reject));
     finished.catch(() => void 0);
     child.stdout.pipe(out);
     child.stdin.on("error", () => void 0);
@@ -3959,8 +3959,8 @@ async function packObjectsToFile(repoDir, extraArgs, stdinLines, opts) {
 }
 function delay(ms) {
   let t;
-  const p = new Promise((resolve4) => {
-    t = setTimeout(resolve4, ms);
+  const p = new Promise((resolve5) => {
+    t = setTimeout(resolve5, ms);
     t.unref();
   });
   p.cancel = () => clearTimeout(t);
@@ -4109,12 +4109,12 @@ async function commitPaths(dir, paths, opts) {
   if (paths.length === 0) {
     throw new PublisherError("LOCAL_STATE", "no files selected to commit");
   }
-  const run = { cwd: dir, env: authorEnv(opts) };
+  const run2 = { cwd: dir, env: authorEnv(opts) };
   if (opts.signal) {
-    run.signal = opts.signal;
+    run2.signal = opts.signal;
   }
-  await runGit(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], { ...run, input: paths.join("\0") + "\0" });
-  await runGit(["commit", "-q", "--no-verify", "-m", opts.message], run);
+  await runGit(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], { ...run2, input: paths.join("\0") + "\0" });
+  await runGit(["commit", "-q", "--no-verify", "-m", opts.message], run2);
   const head = await headCommit(dir);
   if (!head) {
     throw new PublisherError("GIT", "commit did not produce HEAD");
@@ -5062,6 +5062,29 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// ../client/src/portal-request.ts
+async function askPortal(fetchImpl, url2, token, body) {
+  try {
+    const res = await fetchImpl(url2, {
+      method: body === void 0 ? "GET" : "POST",
+      headers: { authorization: `Bearer ${token}`, accept: "application/json", ...body === void 0 ? {} : { "content-type": "application/json" } },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await res.text();
+    try {
+      return { status: res.status, body: text ? JSON.parse(text) : null };
+    } catch {
+      return { status: res.status, body: void 0 };
+    }
+  } catch {
+    return { status: 0, body: null };
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../client/src/application.ts
 var APPLICATION_CREATION = "application-creation";
 var ATTEMPTS = 3;
@@ -5076,7 +5099,7 @@ async function createApplication(input, opts) {
   let refreshed = false;
   let lastOutage = "";
   for (let attempt = 0; attempt < ATTEMPTS; ) {
-    const answer2 = await post(fetchImpl, url2, await opts.token(), body);
+    const answer2 = await askPortal(fetchImpl, url2, await opts.token(), body);
     if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
       refreshed = true;
       if (await opts.refresh()) {
@@ -5102,7 +5125,7 @@ async function createApplication(input, opts) {
     lastOutage = answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}`;
     attempt += 1;
     if (attempt < ATTEMPTS) {
-      await new Promise((resolve4) => setTimeout(resolve4, (opts.retryDelayMs ?? 1e3) * attempt));
+      await new Promise((resolve5) => setTimeout(resolve5, (opts.retryDelayMs ?? 1e3) * attempt));
     }
   }
   throw new PublisherError("UNAVAILABLE", `could not make the application: ${lastOutage}; run init again`, { retryable: true });
@@ -5115,27 +5138,6 @@ function read(body, created) {
   }
   return { appId: application["appId"], created, repository: repository.data };
 }
-async function post(fetchImpl, url2, token, body) {
-  try {
-    const res = await fetchImpl(url2, {
-      method: "POST",
-      headers: { authorization: `Bearer ${token}`, accept: "application/json", "content-type": "application/json" },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
-    });
-    const text = await res.text();
-    try {
-      return { status: res.status, body: text ? JSON.parse(text) : null };
-    } catch {
-      return { status: res.status, body: void 0 };
-    }
-  } catch {
-    return { status: 0, body: null };
-  }
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../client/src/transport.ts
 function assertCredentialEndpoint(endpoint) {
@@ -5251,8 +5253,8 @@ function fallbackCode(status2) {
   return status2 >= 500 ? "UNAVAILABLE" : "INVALID_REQUEST";
 }
 function sleep(ms, signal) {
-  return new Promise((resolve4, reject) => {
-    const t = setTimeout(resolve4, ms);
+  return new Promise((resolve5, reject) => {
+    const t = setTimeout(resolve5, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -5268,14 +5270,14 @@ function sleep(ms, signal) {
 var RUN_STAGES = ["received", "running", "deploying", "live"];
 var STAGE_WORDS = { received: "received", running: "checked", deploying: "going live", live: "live" };
 var STATES = ["pending", "in-progress", "done", "failed", "skipped"];
-function readStages(run) {
-  if (!isRecord3(run)) {
+function readStages(run2) {
+  if (!isRecord3(run2)) {
     return { malformed: "a run that is not an object" };
   }
-  if (!Object.hasOwn(run, "stages")) {
+  if (!Object.hasOwn(run2, "stages")) {
     return null;
   }
-  const stages = run["stages"];
+  const stages = run2["stages"];
   if (!Array.isArray(stages) || stages.length !== RUN_STAGES.length) {
     return { malformed: "stages that are not exactly four" };
   }
@@ -5345,12 +5347,12 @@ async function followRun(input, opts) {
       return { kind: "forbidden" };
     }
     if (answer2.status === 200) {
-      const run = soleRun(answer2.body);
-      if ("detail" in run) {
-        return { kind: "malformed", detail: run.detail };
+      const run2 = soleRun(answer2.body);
+      if ("detail" in run2) {
+        return { kind: "malformed", detail: run2.detail };
       }
-      if (run.run !== null) {
-        const read2 = readStages(run.run);
+      if (run2.run !== null) {
+        const read2 = readStages(run2.run);
         if (read2 === null) {
           return { kind: "unavailable", reason: "no-stages" };
         }
@@ -5367,12 +5369,12 @@ async function followRun(input, opts) {
           opts.onStage?.(entry);
           moved = true;
         }
-        if (isRecord3(run.run) && run.run["status"] === "awaiting-approval") {
+        if (isRecord3(run2.run) && run2.run["status"] === "awaiting-approval") {
           return { kind: "waiting", stages: read2.stages };
         }
         const end = ending(read2.stages);
         if (end !== null) {
-          const runId = isRecord3(run.run) && typeof run.run["runId"] === "string" ? run.run["runId"] : null;
+          const runId = isRecord3(run2.run) && typeof run2.run["runId"] === "string" ? run2.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) {
@@ -5468,7 +5470,7 @@ async function call(input, opts, body) {
   const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/repositories/${encodeURIComponent(input.repoId)}/preparation`;
   let refreshed = false;
   for (; ; ) {
-    const answer2 = await ask2(fetchImpl, url2, await opts.token(), body);
+    const answer2 = await askPortal(fetchImpl, url2, await opts.token(), body);
     if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
       refreshed = true;
       if (await opts.refresh()) {
@@ -5495,7 +5497,7 @@ async function call(input, opts, body) {
   }
 }
 function readView(body) {
-  if (!isRecord4(body)) {
+  if (!isRecord2(body)) {
     return { detail: "an answer that is not a preparation" };
   }
   const { id, revision, status: status2, message, questions, publication } = body;
@@ -5516,12 +5518,12 @@ function readView(body) {
   }
   const read2 = [];
   for (const q of questions) {
-    if (!isRecord4(q) || typeof q["id"] !== "string" || typeof q["text"] !== "string" || !Array.isArray(q["options"]) || q["options"].length === 0) {
+    if (!isRecord2(q) || typeof q["id"] !== "string" || typeof q["text"] !== "string" || !Array.isArray(q["options"]) || q["options"].length === 0) {
       return { detail: "a question that cannot be answered" };
     }
     const options = [];
     for (const o of q["options"]) {
-      if (!isRecord4(o) || typeof o["value"] !== "string" || typeof o["label"] !== "string") {
+      if (!isRecord2(o) || typeof o["value"] !== "string" || typeof o["label"] !== "string") {
         return { detail: "a question with an unreadable option" };
       }
       options.push({ value: o["value"], label: o["label"] });
@@ -5529,7 +5531,7 @@ function readView(body) {
     read2.push({ id: q["id"], text: q["text"], options });
   }
   let pub = null;
-  if (isRecord4(publication) && typeof publication["status"] === "string" && typeof publication["message"] === "string") {
+  if (isRecord2(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: status2, message, questions: read2, publication: pub, findings: readFindings(body["findings"]) };
@@ -5544,7 +5546,7 @@ function readFindings(value) {
     if (out.length === MAX_FINDINGS) {
       break;
     }
-    if (!isRecord4(f)) {
+    if (!isRecord2(f)) {
       continue;
     }
     const kind = text(f["kind"]);
@@ -5566,27 +5568,41 @@ function readFindings(value) {
   }
   return out;
 }
-async function ask2(fetchImpl, url2, token, body) {
-  try {
-    const res = await fetchImpl(url2, {
-      method: body === void 0 ? "GET" : "POST",
-      headers: { authorization: `Bearer ${token}`, accept: "application/json", ...body === void 0 ? {} : { "content-type": "application/json" } },
-      ...body === void 0 ? {} : { body: JSON.stringify(body) },
-      signal: AbortSignal.timeout(3e4)
-    });
-    const text = await res.text();
-    try {
-      return { status: res.status, body: text ? JSON.parse(text) : null };
-    } catch {
-      return { status: res.status, body: void 0 };
+
+// ../client/src/creator-tools.ts
+var CREATOR_TOOLS = "creator-tools";
+async function runCreatorTool(input, opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/tools/${encodeURIComponent(input.tool)}`;
+  let refreshed = false;
+  for (; ; ) {
+    const answer2 = await askPortal(fetchImpl, url2, await opts.token(), input.args);
+    if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
+      refreshed = true;
+      if (await opts.refresh()) {
+        continue;
+      }
     }
-  } catch {
-    return { status: 0, body: null };
+    if (answer2.status === 401) {
+      return { kind: "unauthorized" };
+    }
+    if (answer2.status === 403) {
+      return { kind: "forbidden" };
+    }
+    if (answer2.status === 404) {
+      return { kind: "unavailable", detail: "the portal does not serve this tool" };
+    }
+    if (answer2.status !== 200) {
+      return { kind: "unavailable", detail: answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}` };
+    }
+    const body = answer2.body;
+    if (!isRecord2(body) || typeof body["say"] !== "string" || typeof body["next"] !== "string") {
+      return { kind: "malformed", detail: "an answer with no say and next" };
+    }
+    const { say, next, isError, ...fields } = body;
+    return { kind: "answer", answer: { say, next, isError: isError === true, fields } };
   }
 }
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../client/src/onboard.ts
 var import_promises6 = require("node:fs/promises");
@@ -6374,6 +6390,14 @@ var Publisher = class {
   async answerPreparation(input) {
     return answerPreparation(input, this.portalCall());
   }
+  /**
+   * One of the creator's tools at the portal that serves this endpoint — starters, status, history,
+   * going back, suggestions, sharing — with this publisher's credential and its one refresh. The
+   * caller confirms the portal's `/config` lists `CREATOR_TOOLS` first.
+   */
+  async runCreatorTool(input) {
+    return runCreatorTool(input, this.portalCall());
+  }
   portalCall() {
     return {
       token: this.tokenFn,
@@ -6782,6 +6806,11 @@ var OPTIONS = {
   theirs: { type: "string" },
   to: { type: "string" },
   cursor: { type: "string" },
+  replaces: { type: "string" },
+  run: { type: "string" },
+  answers: { type: "string" },
+  add: { type: "string", multiple: true },
+  remove: { type: "string", multiple: true },
   ref: { type: "string", multiple: true },
   json: { type: "boolean" },
   quiet: { type: "boolean" },
@@ -6946,13 +6975,13 @@ function stageReporter(io) {
 // src/follow.ts
 async function followPublication(p, endpoint, o, opts) {
   const derived = portalForEndpoint(endpoint);
-  const confirmed = derived === null ? null : await confirmPortal(derived, endpoint, opts.fetch);
-  const portal = confirmed === null ? null : derived;
+  const confirmed2 = derived === null ? null : await confirmPortal(derived, endpoint, opts.fetch);
+  const portal = confirmed2 === null ? null : derived;
   const elsewhere = (reason) => ({ kind: "unavailable", reason, portal, hint: inPortal(portal, "Published.", "Follow it") });
-  if (portal === null || confirmed === null) {
+  if (portal === null || confirmed2 === null) {
     return elsewhere("no-portal");
   }
-  if (!confirmed.terminal.includes(RUN_PROGRESS)) {
+  if (!confirmed2.terminal.includes(RUN_PROGRESS)) {
     const noRoute = { kind: "unavailable", reason: "no-route" };
     return { ...noRoute, portal, hint: progressHint(noRoute, portal) };
   }
@@ -6966,7 +6995,7 @@ async function followPublication(p, endpoint, o, opts) {
     { portal, repoId: o.repoId, publicationId: o.publicationId, ref, commit },
     { onStage: opts.onStage, ...opts.timeoutMs === void 0 ? {} : { timeoutMs: opts.timeoutMs }, ...opts.untilChange === true ? { untilChange: true } : {} }
   ).finally(() => opts.stopStages?.());
-  const answerable = confirmed.terminal.includes(PREPARATION);
+  const answerable = confirmed2.terminal.includes(PREPARATION);
   const dir = shellWord(opts.dir);
   const next = outcome2.kind === "timed-out" || outcome2.kind === "moving" ? { action: "follow", command: `publisher follow ${dir} --publication ${o.publicationId}${opts.untilChange === true ? " --until-change" : ""} --json` } : outcome2.kind === "waiting" && answerable ? { action: "question", command: `publisher question ${dir} --json` } : void 0;
   const findings = await failedChecks(p, portal, o.repoId, outcome2, answerable);
@@ -7080,7 +7109,7 @@ function resolveChoice(answer2, names) {
   }
   return names.find((n) => n.toLowerCase() === a.toLowerCase()) ?? null;
 }
-async function ask3(question2) {
+async function ask2(question2) {
   const rl = (0, import_promises11.createInterface)({ input: process.stdin, output: process.stderr });
   try {
     return await rl.question(question2);
@@ -7098,7 +7127,7 @@ ${purpose}
   names.forEach((n, i) => process.stderr.write(`  ${i + 1}) ${n}
 `));
   for (let attempt = 0; attempt < 3; attempt++) {
-    const answer2 = await ask3(`
+    const answer2 = await ask2(`
 Which one? [1-${names.length}, or a name] `);
     if (answer2 === null) {
       return null;
@@ -7118,7 +7147,7 @@ Name this connection, so you never have to type ${endpoint} again.
 (for example: prod, dev, staging)
 `);
   for (let attempt = 0; attempt < 3; attempt++) {
-    const answer2 = await ask3(suggested ? `
+    const answer2 = await ask2(suggested ? `
 Profile name [${suggested}]: ` : `
 Profile name: `);
     if (answer2 === null) {
@@ -7407,14 +7436,14 @@ function packageVersion() {
   }
 }
 function claude(args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
     const child = (0, import_node_child_process3.spawn)("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
     child.stdout.on("data", (d) => stdout += d.toString("utf8"));
     child.stderr.on("data", (d) => stderr += d.toString("utf8"));
-    child.on("error", (e) => resolve4({ code: null, stdout, stderr: e.message, missing: e.code === "ENOENT" }));
-    child.on("close", (code) => resolve4({ code, stdout, stderr, missing: false }));
+    child.on("error", (e) => resolve5({ code: null, stdout, stderr: e.message, missing: e.code === "ENOENT" }));
+    child.on("close", (code) => resolve5({ code, stdout, stderr, missing: false }));
   });
 }
 async function installSkills({ log }) {
@@ -7555,11 +7584,11 @@ async function repositoryForInit(p, endpoint, name, opts = {}) {
   if (portal === null) {
     return { repoId: (await p.createRepository({ name, grants: [] })).repoId, appId: null };
   }
-  const confirmed = await confirmPortal(portal, endpoint, opts.fetch);
-  if (confirmed === null) {
+  const confirmed2 = await confirmPortal(portal, endpoint, opts.fetch);
+  if (confirmed2 === null) {
     throw new PublisherError("UNAVAILABLE", `could not confirm that ${portal} publishes to ${endpoint}; run init again`, { retryable: true });
   }
-  if (!confirmed.terminal.includes(APPLICATION_CREATION)) {
+  if (!confirmed2.terminal.includes(APPLICATION_CREATION)) {
     throw new PublisherError("UNAVAILABLE", `${portal} cannot make an application from a terminal yet, and a repository needs one; ask whoever runs it to update the portal`);
   }
   const made = await p.createApplication({ portal, name });
@@ -7716,6 +7745,24 @@ function folderFor(name) {
   return slug2 === "" ? "app" : slug2;
 }
 
+// src/portal.ts
+var confirmed = /* @__PURE__ */ new Map();
+async function portalFor(endpoint, route, opts = {}) {
+  const derived = portalForEndpoint(endpoint);
+  if (derived === null) {
+    return { kind: "no-portal" };
+  }
+  const asked = opts.fetch === void 0 ? confirmed.get(endpoint) ?? confirmPortal(derived, endpoint) : confirmPortal(derived, endpoint, opts.fetch);
+  if (opts.fetch === void 0) {
+    confirmed.set(endpoint, asked);
+  }
+  const config2 = await asked;
+  if (config2 === null) {
+    return { kind: "no-portal" };
+  }
+  return config2.terminal.includes(route) ? { kind: "served", portal: derived } : { kind: "no-route", portal: derived };
+}
+
 // src/question.ts
 async function questionAt(p, endpoint, repoId, opts = {}) {
   const at = await portalAt(endpoint, opts);
@@ -7766,15 +7813,20 @@ function parseSpecs(specs) {
   return answers;
 }
 async function portalAt(endpoint, opts) {
-  const derived = portalForEndpoint(endpoint);
-  const confirmed = derived === null ? null : await confirmPortal(derived, endpoint, opts.fetch);
-  if (derived === null || confirmed === null) {
-    return { kind: "unavailable", reason: "no-portal", portal: null, hint: "Answer it in the portal." };
-  }
-  if (!confirmed.terminal.includes(PREPARATION)) {
-    return { kind: "unavailable", reason: "no-route", portal: derived, hint: `This portal cannot show the question in the terminal yet. Answer it in the portal: ${derived}.` };
+  const at = await portalFor(endpoint, PREPARATION, opts);
+  switch (at.kind) {
+    case "served":
+      return { portal: at.portal };
+    case "no-portal":
+      return { kind: "unavailable", reason: "no-portal", portal: null, hint: "Answer it in the portal." };
+    case "no-route":
+      return {
+        kind: "unavailable",
+        reason: "no-route",
+        portal: at.portal,
+        hint: `This portal cannot show the question in the terminal yet. Answer it in the portal: ${at.portal}.`
+      };
   }
-  return { portal: derived };
 }
 function shown(portal, r) {
   switch (r.kind) {
@@ -7843,6 +7895,116 @@ var answer = {
   }
 };
 
+// src/commands/creator.ts
+var import_node_path10 = require("node:path");
+
+// src/creator.ts
+async function creatorTool(p, endpoint, tool, args, opts = {}) {
+  const at = await portalFor(endpoint, CREATOR_TOOLS, opts);
+  if (at.kind === "no-portal") {
+    throw new PublisherError("UNAVAILABLE", "no portal answers for this endpoint, so this can only be done in the chat or the portal");
+  }
+  if (at.kind === "no-route") {
+    throw new PublisherError("UNAVAILABLE", `this portal cannot do this from the terminal yet; do it in the chat or at ${at.portal}`);
+  }
+  const result = await p.runCreatorTool({ portal: at.portal, tool, args });
+  switch (result.kind) {
+    case "answer":
+      return result.answer;
+    case "unauthorized":
+      throw new PublisherError("UNAUTHORIZED", "the portal did not accept this sign-in; run publisher login");
+    case "forbidden":
+      throw new PublisherError("FORBIDDEN", "the portal will not let this sign-in do that in this organisation");
+    case "unavailable":
+      throw new PublisherError("UNAVAILABLE", `the portal could not be asked: ${result.detail}`, { retryable: true });
+    case "malformed":
+      throw new PublisherError("UNAVAILABLE", `the portal's answer could not be read: ${result.detail}`);
+  }
+}
+function printed(answer2) {
+  return { say: answer2.say, next: answer2.next, refused: answer2.isError, ...answer2.fields };
+}
+
+// src/commands/creator.ts
+async function run(inv, dir, tool, args) {
+  const { p, endpoint } = await inv.client(dir);
+  const answer2 = await creatorTool(p, endpoint, tool, args);
+  inv.out(printed(answer2));
+  return answer2.isError ? 1 : 0;
+}
+async function folderApp(inv) {
+  const dir = (0, import_node_path10.resolve)(".");
+  return { dir, app: await inv.repoId(dir) };
+}
+function listFlag(inv, name) {
+  const value = inv.flags[name];
+  const parts = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return parts.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v !== "");
+}
+var starters = {
+  git: false,
+  run: (inv) => run(inv, void 0, "list_starters", { need: inv.cmd.slice(1).join(" ") })
+};
+var start = {
+  git: false,
+  async run(inv) {
+    const starter = inv.cmd[1];
+    if (starter === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "start takes a starter id; publisher starters lists them");
+    }
+    return run(inv, void 0, "use_starter", { starter, ...inv.optStr("name"), ...inv.optStr("replaces") });
+  }
+};
+var history = {
+  git: false,
+  async run(inv) {
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "app_history", { app });
+  }
+};
+var goBack = {
+  git: false,
+  async run(inv) {
+    const version2 = Number(inv.cmd[1]);
+    if (!Number.isSafeInteger(version2) || version2 < 1) {
+      throw new PublisherError("INVALID_REQUEST", "go-back takes a version number; publisher history lists them");
+    }
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "go_back", { app, version: version2 });
+  }
+};
+var suggestions = {
+  git: false,
+  async run(inv) {
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "app_suggestions", { app });
+  }
+};
+var suggestion = {
+  git: false,
+  async run(inv) {
+    const [, verb, id] = inv.cmd;
+    if (verb !== "done" && verb !== "decline" || id === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "suggestion takes done or decline, and a suggestion id from publisher suggestions");
+    }
+    const { dir, app } = await folderApp(inv);
+    const status2 = verb === "done" ? "done" : "declined";
+    const runId = inv.str("run");
+    return run(inv, dir, "resolve_suggestion", { app, suggestion: id, status: status2, ...runId === void 0 ? {} : { runId } });
+  }
+};
+var share = {
+  git: false,
+  async run(inv) {
+    const access2 = inv.cmd[1];
+    if (access2 === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "share takes organisation, invited or anyone-with-link");
+    }
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "share_app", { app, access: access2, add: listFlag(inv, "add"), remove: listFlag(inv, "remove") });
+  }
+};
+
 // src/commands/sync.ts
 var sync = {
   git: true,
@@ -7861,6 +8023,7 @@ var sync = {
     const acceptedAt = sending.done();
     const o = r.published;
     const followed = o !== null && o.state === "accepted" && inv.flags["no-wait"] !== true ? await followPublication(p, endpoint, o, { ...inv.following, timeoutMs, dir }) : null;
+    const answered = await answerSuggestion(inv, p, endpoint, linked?.repoId ?? (await readAssociation(dir))?.repoId, o);
     const syncTimings = clock.read(followed !== null && "stages" in followed ? runTimings(followed.stages, acceptedAt) : {});
     inv.log(timingsLine(syncTimings));
     inv.out({
@@ -7869,11 +8032,26 @@ var sync = {
       linked: linked === null ? null : { repoId: linked.repoId, appId: linked.appId, created: linked.created },
       ...outcome(r),
       progress: followed,
+      ...answered === null ? {} : { answered },
       timings: syncTimings
     });
     return r.state === "published" || r.state === "up_to_date" ? 0 : r.state === "unknown" ? 3 : 2;
   }
 };
+async function answerSuggestion(inv, p, endpoint, repoId, o) {
+  const id = inv.str("answers");
+  if (id === void 0 || repoId === void 0 || o === null || o.state !== "accepted" || o.publicationId === null) {
+    return null;
+  }
+  const ref = "refs/heads/main";
+  const commit = o.refs?.[ref];
+  if (commit === void 0) {
+    return null;
+  }
+  return printed(
+    await creatorTool(p, endpoint, "resolve_suggestion", { app: repoId, suggestion: id, status: "done", publication: { publicationId: o.publicationId, ref, commit } })
+  );
+}
 function outcome(r) {
   const o = r.published;
   return {
@@ -8009,7 +8187,7 @@ function exitCodeFor(code) {
 }
 
 // src/invocation.ts
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 var Invocation = class {
   cmd;
   flags;
@@ -8052,7 +8230,7 @@ var Invocation = class {
   };
   /** The folder named at position `i` of the command path, or the current one. */
   dirArg(i) {
-    return (0, import_node_path10.resolve)(this.cmd[i] ?? ".");
+    return (0, import_node_path11.resolve)(this.cmd[i] ?? ".");
   }
   /** A flag's value when it is a string, else undefined. */
   str(key) {
@@ -8109,15 +8287,15 @@ async function demand(r, input) {
   }
   const next = nextStep(credentialStatus(input));
   const details = { profiles: r.kind === "none" ? [] : r.profiles, next };
-  const run = next.command === null ? "" : ` Run: ${next.command}`;
+  const run2 = next.command === null ? "" : ` Run: ${next.command}`;
   switch (r.kind) {
     case "unknown-profile":
-      throw new PublisherError("LOCAL_STATE", `no such profile: ${r.name}.${run}`, { details });
+      throw new PublisherError("LOCAL_STATE", `no such profile: ${r.name}.${run2}`, { details });
     case "ambiguous":
-      throw new PublisherError("LOCAL_STATE", `several connections and none is the default: pass --profile <name>, or choose one once.${run}`, { details });
+      throw new PublisherError("LOCAL_STATE", `several connections and none is the default: pass --profile <name>, or choose one once.${run2}`, { details });
     case "none": {
       const where = await whereCredentialsWere();
-      throw new PublisherError("LOCAL_STATE", `not connected to a publishing service yet: ${where.sentence}${run}`, { details: { ...details, credentialsFile: where.details } });
+      throw new PublisherError("LOCAL_STATE", `not connected to a publishing service yet: ${where.sentence}${run2}`, { details: { ...details, credentialsFile: where.details } });
     }
   }
 }
@@ -8164,12 +8342,22 @@ Usage:
                                                         checked -> going live -> live, up to 15 minutes)
       [--timeout <seconds>]                             follow for at most this long; if it is still going, the
                                                         result's next.command picks it up
+      [--answers <suggestion>]                          the publication answers that suggestion: close it as done
   publisher follow [dir] --publication <id>             follow an accepted publication's run where a sync left it
       [--timeout <seconds>] [--until-change]            --until-change (sync too): return at the next step, to tell it
   publisher question [dir] [--repo <id>]                the question the app's preparation waits on, if any,
                                                         with each option's value (answering needs owner or admin)
   publisher answer <question>=<value>... [--repo <id>]  answer it from this folder; a value that is not one of
                                                         the question's options is refused before anything is sent
+  publisher starters [what you want to stop doing]      working apps to start from, the ones that fit first
+  publisher start <starter> [--name <n>] [--replaces <what>]   a new app made from a starter, live in about a minute
+  publisher history                                     this folder's app: the versions that went live, newest first
+  publisher go-back <version>                           put the code of an earlier version back, as the next version
+                                                        (the data and who can open the app stay as they are)
+  publisher suggestions                                 what colleagues suggested for this folder's app, still open
+  publisher suggestion done|decline <id> [--run <id>]   close one; sync --answers <id> closes it with that publication
+  publisher share organisation|invited|anyone-with-link [--add <emails>] [--remove <emails>]
+                                                        who can open this folder's app; new invitees get the link by mail
   publisher merge-check [dir] --ours <ref> --theirs <ref> [--apply]
   publisher info [dir]                                   repository state as seen by the server
   publisher doctor                                       environment check (node, git, credentials, association)
@@ -8213,7 +8401,14 @@ var COMMANDS = /* @__PURE__ */ new Map([
   ["answer", answer],
   ["skills", skills],
   ["merge-check", mergeCheck2],
-  ["info", info]
+  ["info", info],
+  ["starters", starters],
+  ["start", start],
+  ["history", history],
+  ["go-back", goBack],
+  ["suggestions", suggestions],
+  ["suggestion", suggestion],
+  ["share", share]
 ]);
 async function main(argv) {
   const inv = new Invocation(parseArgs(argv));

package/package.json

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