@minnovate/shadow-publisher 0.7.0 → 0.8.3

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

@@ -1,7 +1,7 @@
 {
   "name": "git-publisher",
   "displayName": "Git Publisher",
-  "version": "0.7.0",
+  "version": "0.8.3",
   "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

@@ -56,24 +56,16 @@ changing their default.
 
 ## 2. First publication of a folder
 
-Run in the app folder (the folder the user is working in):
+There is no separate first step: run step 3 in the app folder, adding `--name "<app name>"` the
+first time. A folder that is not published yet gets its application and repository from that same
+`sync` (the portal makes the application first, in one request), and is then published.
 
-```bash
-publisher info --json            # exit 1 with LOCAL_STATE "not associated" means: not published yet
-```
-
-If not associated:
-
-```bash
-publisher init . --name "<app name>" --json
-```
-
-`init` prepares the folder with an explicit file selection: it excludes `.git`, `node_modules`,
-build caches, `.env*`, keys/certificates and files larger than 50 MB, and it respects
-`.gitignore`. Show the user the `onboarding.excluded` list so they know what was left out (the
-exclusion rules are a safety net, not a secret scanner). Then publish it with step 3.
+The first `sync` prepares the folder with an explicit file selection: it excludes `.git`,
+`node_modules`, build caches, `.env*`, keys/certificates and files larger than 50 MB, and it
+respects `.gitignore`. Show the user the `linked` result and the excluded files it reports so they
+know what was left out (the exclusion rules are a safety net, not a secret scanner).
 
-## 3. Every update — and the first publish after `init`
+## 3. Every publish, the first one included
 
 ```bash
 publisher sync . --message "<a few words on what changed>" --timeout 90 --json

package/dist/publisher.cjs

@@ -97,6 +97,11 @@ var ERROR_CODES = [
   // code rather than FORBIDDEN: a caller can act on it (sign in again, choosing an organisation),
   // and a test that could not tell it from "you may not" would prove nothing about the check.
   "ORGANISATION_REQUIRED",
+  // A repository is created only by the platform's application maker (the portal), for a person,
+  // after it has made the application the repository will belong to. Its own code: a terminal that
+  // meets it is an older client calling this route directly, and can say "upgrade" rather than
+  // "you may not".
+  "APPLICATION_REQUIRED",
   // repositories
   "REPOSITORY_NOT_FOUND",
   "REPOSITORY_CONFLICT",
@@ -139,6 +144,7 @@ var HTTP_STATUS_FOR_CODE = {
   FORBIDDEN: 403,
   REF_FORBIDDEN: 403,
   ORGANISATION_REQUIRED: 403,
+  APPLICATION_REQUIRED: 403,
   REPOSITORY_NOT_FOUND: 404,
   REPOSITORY_CONFLICT: 409,
   REPOSITORY_ARCHIVED: 409,
@@ -2666,6 +2672,11 @@ var OwnerMarker = object({
   repoId: RepoId,
   createdAt: IsoDate
 });
+var RepositoryOrganisation = object({
+  schemaVersion: SchemaVersion,
+  repoId: RepoId,
+  org: OrgId
+});
 var MetaRecord = object({
   schemaVersion: SchemaVersion,
   repoId: RepoId,
@@ -2824,13 +2835,9 @@ var CapabilitiesResponse = object({
   storageSchemaVersion: int(),
   server: object({ name: string2(), version: string2(), git: string2() }),
   /**
-   * Either may be EMPTY, and the schema says so because the server can send it.
-   *
-   * `url()` claimed otherwise while `control` was already
-   * deliberately empty when a deployment cannot determine its own public address — a client
-   * reads that as "it did not say", which is the answer, and is why it must parse rather than
-   * fail. Whoever publishes a value states its type; a schema that refuses what the producer
-   * emits is a mismatch waiting to be found by a consumer.
+   * Either may be EMPTY, and the schema says so because the server can send it: `control` is empty
+   * when a deployment cannot determine its own public address, which a client reads as "it did not
+   * say", so it must parse rather than fail. `url()` was rejected for that reason (#40).
    */
   endpoints: object({
     control: string2(),
@@ -2854,6 +2861,8 @@ var CreateRepositoryRequest = object({
   objectFormat: _default(ObjectFormat, "sha1"),
   grants: _default(array(Grant).check(_maxLength(200)), [])
 });
+var RepositoryIdRequest = object({ creationId: CreationId });
+var RepositoryIdResponse = object({ repoId: RepoId });
 var RepositoryInfo = object({
   repoId: RepoId,
   name: string2(),
@@ -2938,6 +2947,7 @@ var BundleBootstrapResponse = object({
 // ../protocol/src/keys.ts
 var PENDING_KEY_RE = new RegExp(`^pending/(${REPO_ID_RE.source.slice(1, -1)})/(${PUBLICATION_ID_RE.source.slice(1, -1)})$`);
 var OWNER_KEY_RE = new RegExp(`^owners/(${PRINCIPAL_ID_RE.source.slice(1, -1)})/(${REPO_ID_RE.source.slice(1, -1)})$`);
+var REPOSITORY_ORGANISATION_KEY_RE = new RegExp(`^repository-organisations/(${REPO_ID_RE.source.slice(1, -1)})\\.json$`);
 
 // ../protocol/src/index.ts
 var MAX_WAIT_SECONDS = 5;
@@ -4499,6 +4509,69 @@ async function updateEntry(url2, change) {
   await writeCredentials(file);
 }
 
+// ../client/src/application.ts
+var APPLICATION_CREATION = "application-creation";
+var ATTEMPTS = 3;
+var REFUSALS = {
+  "repository-limit": "LIMIT_EXCEEDED",
+  "repository-conflict": "REPOSITORY_CONFLICT"
+};
+async function createApplication(input, opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/applications`;
+  const body = { creationId: input.creationId ?? newCreationId(), name: input.name, defaultBranch: input.defaultBranch ?? "main" };
+  let refreshed = false;
+  let lastOutage = "";
+  for (let attempt = 0; attempt < ATTEMPTS; ) {
+    const answer = await post(fetchImpl, url2, await opts.token(), body);
+    if (answer.status === 401 && !refreshed && opts.refresh !== void 0) {
+      refreshed = true;
+      if (await opts.refresh()) continue;
+    }
+    if (answer.status === 200 || answer.status === 201) return read(answer.body, answer.status === 201);
+    const code = isRecord(answer.body) && typeof answer.body["error"] === "string" ? answer.body["error"] : "";
+    if (answer.status === 401) throw new PublisherError("UNAUTHORIZED", 'the portal did not accept this credential; run "publisher login" again');
+    if (answer.status === 403) throw new PublisherError("FORBIDDEN", `the portal refused to make an application here (${code || "forbidden"})`);
+    if (answer.status === 409 && REFUSALS[code] !== void 0)
+      throw new PublisherError(REFUSALS[code], `the portal refused the repository (${code})`, { details: { portal: code } });
+    if (answer.status === 400 || answer.status === 409)
+      throw new PublisherError("INVALID_REQUEST", `the portal refused the request (${code || answer.status})`, { details: { portal: code } });
+    lastOutage = answer.status === 0 ? "the portal could not be reached" : `the portal answered ${answer.status}`;
+    attempt += 1;
+    if (attempt < ATTEMPTS) await new Promise((resolve3) => setTimeout(resolve3, (opts.retryDelayMs ?? 1e3) * attempt));
+  }
+  throw new PublisherError("UNAVAILABLE", `could not make the application: ${lastOutage}; run init again`, { retryable: true });
+}
+function read(body, created) {
+  const application = isRecord(body) ? body["application"] : void 0;
+  const repository = RepositoryInfo.safeParse(isRecord(body) ? body["repository"] : void 0);
+  if (!isRecord(application) || typeof application["appId"] !== "string" || !repository.success) {
+    throw new PublisherError("UNAVAILABLE", "the portal answered with an application this version cannot read");
+  }
+  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 isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../client/src/transport.ts
 function assertCredentialEndpoint(endpoint) {
   let url2;
@@ -4615,14 +4688,14 @@ 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 (!isRecord(run)) return { malformed: "a run that is not an object" };
+  if (!isRecord2(run)) return { malformed: "a run that is not an object" };
   if (!Object.hasOwn(run, "stages")) return null;
   const stages = run["stages"];
   if (!Array.isArray(stages) || stages.length !== RUN_STAGES.length) return { malformed: "stages that are not exactly four" };
   const out = [];
   for (const [index, entry] of stages.entries()) {
     const stage = RUN_STAGES[index];
-    if (!isRecord(entry) || entry["stage"] !== stage) return { malformed: `stage ${index + 1} is not ${stage}` };
+    if (!isRecord2(entry) || entry["stage"] !== stage) return { malformed: `stage ${index + 1} is not ${stage}` };
     const state = entry["state"];
     if (!STATES.includes(state)) return { malformed: `stage ${stage} has an unknown state` };
     const at = entry["at"];
@@ -4665,18 +4738,18 @@ async function followRun(input, opts) {
       const run = soleRun(answer.body);
       if ("detail" in run) return { kind: "malformed", detail: run.detail };
       if (run.run !== null) {
-        const read = readStages(run.run);
-        if (read === null) return { kind: "unavailable", reason: "no-stages" };
-        if ("malformed" in read) return { kind: "malformed", detail: read.malformed };
-        last = read.stages;
-        for (const entry of read.stages) {
+        const read2 = readStages(run.run);
+        if (read2 === null) return { kind: "unavailable", reason: "no-stages" };
+        if ("malformed" in read2) return { kind: "malformed", detail: read2.malformed };
+        last = read2.stages;
+        for (const entry of read2.stages) {
           if (entry.state === "pending" || seen.get(entry.stage) === entry.state) continue;
           seen.set(entry.stage, entry.state);
           opts.onStage?.(entry);
         }
-        if (isRecord(run.run) && run.run["status"] === "awaiting-approval") return { kind: "waiting", stages: read.stages };
-        const end = ending(read.stages);
-        if (end !== null) return { kind: "settled", ending: end, failedAt: read.stages.find((s) => s.state === "failed")?.word ?? null, stages: read.stages };
+        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 };
       }
       lastError = null;
     } else {
@@ -4687,7 +4760,7 @@ async function followRun(input, opts) {
   }
 }
 function soleRun(body) {
-  if (!isRecord(body) || !Array.isArray(body["runs"])) return { detail: "an answer with no list of runs" };
+  if (!isRecord2(body) || !Array.isArray(body["runs"])) return { detail: "an answer with no list of runs" };
   const runs = body["runs"];
   if (runs.length > 1) return { detail: "more than the one run this publication started" };
   return { run: runs[0] ?? null };
@@ -4732,7 +4805,7 @@ async function confirmPortal(portal, endpoint, fetchImpl = fetch) {
     return null;
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -4759,7 +4832,7 @@ async function call(input, opts, body) {
     if (answer.status === 403) return { kind: "forbidden" };
     if (answer.status === 409) return { kind: "moved-on" };
     if (answer.status === 404) {
-      const code = isRecord2(answer.body) ? answer.body["error"] : void 0;
+      const code = isRecord3(answer.body) ? answer.body["error"] : void 0;
       return code === "no-such-application" ? { kind: "no-application" } : { kind: "unavailable", detail: "the portal does not serve this address" };
     }
     if (answer.status === 200) {
@@ -4770,30 +4843,30 @@ async function call(input, opts, body) {
   }
 }
 function readView(body) {
-  if (!isRecord2(body)) return { detail: "an answer that is not a preparation" };
+  if (!isRecord3(body)) return { detail: "an answer that is not a preparation" };
   const { id, revision, status, message, questions, publication } = body;
   if (typeof id !== "string" || id === "") return { detail: "a preparation with no id" };
   if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 1) return { detail: "a preparation with no revision" };
   if (!STATUSES.includes(status)) return { detail: "a preparation with an unknown status" };
   if (typeof message !== "string") return { detail: "a preparation with no message" };
   if (!Array.isArray(questions)) return { detail: "a preparation with no list of questions" };
-  const read = [];
+  const read2 = [];
   for (const q of questions) {
-    if (!isRecord2(q) || typeof q["id"] !== "string" || typeof q["text"] !== "string" || !Array.isArray(q["options"]) || q["options"].length === 0) {
+    if (!isRecord3(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 (!isRecord2(o) || typeof o["value"] !== "string" || typeof o["label"] !== "string") return { detail: "a question with an unreadable option" };
+      if (!isRecord3(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"] });
     }
-    read.push({ id: q["id"], text: q["text"], options });
+    read2.push({ id: q["id"], text: q["text"], options });
   }
   let pub = null;
-  if (isRecord2(publication) && typeof publication["status"] === "string" && typeof publication["message"] === "string") {
+  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: read, publication: pub };
+  return { id, revision, status, message, questions: read2, publication: pub };
 }
 async function ask2(fetchImpl, url2, token, body) {
   try {
@@ -4813,7 +4886,7 @@ async function ask2(fetchImpl, url2, token, body) {
     return { status: 0, body: null };
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -5480,6 +5553,14 @@ var Publisher = class {
       fetch: this.fetchImpl
     });
   }
+  /**
+   * A new application and its repository, made by the portal that serves this endpoint — the only
+   * way a repository is created on a deployed stage (ADR-0016 A1). The caller confirms the portal's
+   * `/config` lists `APPLICATION_CREATION` first, as it does for the other terminal routes.
+   */
+  async createApplication(input) {
+    return createApplication(input, this.portalCall());
+  }
   /**
    * The question the repository's current preparation waits on, and its answer, at the portal that
    * serves this endpoint — with this publisher's credential and its one refresh, as `followRun`.
@@ -5737,8 +5818,8 @@ async function deviceLogin(opts) {
   if (typeof advertised !== "string" || advertised === "") throw new PublisherError("UNAVAILABLE", "this deployment does not offer device login; obtain a token another way");
   const base = normalize(advertised);
   assertCredentialEndpoint(base);
-  const post = (path, fields) => postForm(base, path, fields, doFetch);
-  const started = await post("/v1/auth/device", { client_id: opts.clientId ?? "gitpub-cli" });
+  const post2 = (path, fields) => postForm(base, path, fields, doFetch);
+  const started = await post2("/v1/auth/device", { client_id: opts.clientId ?? "gitpub-cli" });
   if (started.status !== 200) throw new PublisherError("UNAVAILABLE", `starting the login failed (${started.status})`, { retryable: true });
   const s = started.body;
   const deviceCode = str(s.device_code);
@@ -5752,7 +5833,7 @@ async function deviceLogin(opts) {
   for (; ; ) {
     await sleep2(intervalMs);
     if (now() >= deadline) throw new PublisherError("EXPIRED", "the login expired before it was approved");
-    const polled = await post("/v1/auth/token", { grant_type: DEVICE_CODE_GRANT, device_code: deviceCode });
+    const polled = await post2("/v1/auth/token", { grant_type: DEVICE_CODE_GRANT, device_code: deviceCode });
     if (polled.status === 200) {
       const token = str(polled.body["access_token"]);
       if (!token) throw new PublisherError("UNAVAILABLE", "the login returned no credential");
@@ -5799,6 +5880,21 @@ async function discoverEndpoint(portal, fetchImpl = fetch) {
   return endpoint;
 }
 
+// src/init.ts
+async function repositoryForInit(p, endpoint, name, opts = {}) {
+  const portal = portalForEndpoint(endpoint);
+  if (portal === null) return { repoId: (await p.createRepository({ name, grants: [] })).repoId, appId: null };
+  const confirmed = await confirmPortal(portal, endpoint, opts.fetch);
+  if (confirmed === null) {
+    throw new PublisherError("UNAVAILABLE", `could not confirm that ${portal} publishes to ${endpoint}; run init again`, { retryable: true });
+  }
+  if (!confirmed.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 });
+  return { repoId: made.repository.repoId, appId: made.appId };
+}
+
 // src/login.ts
 async function verifiedCapabilities(publisher) {
   const caps = await publisher.getCapabilities();
@@ -6034,22 +6130,22 @@ async function answerAt(p, endpoint, repoId, specs, opts = {}) {
   const answers = parseSpecs(specs);
   const at = await portalAt(endpoint, opts);
   if ("reason" in at) return at;
-  const read = shown(at.portal, await p.readPreparation({ portal: at.portal, repoId }));
-  if (read.kind !== "view") return read;
-  if (read.questions.length === 0) throw new PublisherError("LOCAL_STATE", `nothing is waiting for an answer (the preparation is ${read.preparation.status})`);
+  const read2 = shown(at.portal, await p.readPreparation({ portal: at.portal, repoId }));
+  if (read2.kind !== "view") return read2;
+  if (read2.questions.length === 0) throw new PublisherError("LOCAL_STATE", `nothing is waiting for an answer (the preparation is ${read2.preparation.status})`);
   for (const [id, value] of Object.entries(answers)) {
-    const question = read.questions.find((q) => q.id === id);
+    const question = read2.questions.find((q) => q.id === id);
     if (question === void 0) {
-      throw new PublisherError("INVALID_REQUEST", `no pending question "${id}"; pending: ${read.questions.map((q) => q.id).join(", ")}`, {
-        details: { questions: read.questions }
+      throw new PublisherError("INVALID_REQUEST", `no pending question "${id}"; pending: ${read2.questions.map((q) => q.id).join(", ")}`, {
+        details: { questions: read2.questions }
       });
     }
     const values = question.options.map((o) => o.value);
     if (!values.includes(value)) {
-      throw new PublisherError("INVALID_REQUEST", `"${value}" is not one of ${values.join(", ")} for "${id}"`, { details: { questions: read.questions } });
+      throw new PublisherError("INVALID_REQUEST", `"${value}" is not one of ${values.join(", ")} for "${id}"`, { details: { questions: read2.questions } });
     }
   }
-  return shown(at.portal, await p.answerPreparation({ portal: at.portal, repoId, id: read.preparation.id, revision: read.preparation.revision, answers }));
+  return shown(at.portal, await p.answerPreparation({ portal: at.portal, repoId, id: read2.preparation.id, revision: read2.preparation.revision, answers }));
 }
 function parseSpecs(specs) {
   if (specs.length === 0) throw new PublisherError("INVALID_REQUEST", "answer takes one or more question=value");
@@ -6119,7 +6215,8 @@ Usage:
   publisher fetch [dir]
   publisher checkout <dir> --repo <id> [--branch <name>]  create a NEW editable workspace (never overlays a folder)
   publisher workspace-status [dir]                      offline mapping + where the workspace stands (real three-way check)
-  publisher sync [dir] [--message <text>]               THE way to save and publish a change: records the folder's
+  publisher sync [dir] [--message <text>] [--name <app>] THE way to publish: a folder linked to nothing first gets its
+                                                        application and repository (what init does); then it records the
                                                         changes (never .env, keys or node_modules), brings in what
                                                         was published meanwhile (fast-forward or a clean merge,
                                                         never a rewrite) and publishes. Stops on a conflict with
@@ -6212,6 +6309,31 @@ async function main(argv) {
     const token = str2(flags["token"]);
     return { endpoint, p: createPublisher({ endpoint, endpointSource: source, ...token ? { token } : {}, clientName: "git-publisher-cli", clientVersion: CLIENT_VERSION }) };
   };
+  const linkFolder = async (p, endpoint, dir, attach) => {
+    let onboarding = null;
+    if (!await isGitRepo(dir) || !await headCommit(dir)) {
+      onboarding = await onboardFolder({ dir, ...optStr(flags, "message") });
+      log(`prepared ${onboarding.committed.length} files (${onboarding.excluded.length} excluded)`);
+    }
+    let repoId = attach.repoId ?? null;
+    let appId = null;
+    if (repoId === null) {
+      const made = await repositoryForInit(p, endpoint, str2(flags["name"]) ?? dir.split("/").pop() ?? "");
+      repoId = made.repoId;
+      appId = made.appId;
+    } else {
+      await p.getRepository(repoId);
+    }
+    await p.associate(dir, repoId);
+    const workspace = await p.adoptWorkspace(dir).catch(() => null);
+    return {
+      repoId,
+      appId,
+      created: attach.repoId === void 0,
+      onboarding: onboarding ? { commit: onboarding.commit, committed: onboarding.committed.length, excluded: onboarding.excluded } : null,
+      workspace: workspace === null ? null : { branch: workspace.branch, baseOid: workspace.baseOid, baseGeneration: workspace.baseGeneration }
+    };
+  };
   if (flags["version"] === true) {
     process.stdout.write(`${packageVersion()}
 `);
@@ -6345,33 +6467,9 @@ Waiting (it expires in ${Math.round(expiresInSeconds / 60)} minutes)...
     case "init": {
       const dir = dirArg(1);
       const { p, endpoint } = await client();
-      const existing = await isGitRepo(dir);
-      let onboarding = null;
-      if (!existing || !await headCommit(dir)) {
-        onboarding = await onboardFolder({ dir, ...optStr(flags, "message") });
-        log(`prepared ${onboarding.committed.length} files (${onboarding.excluded.length} excluded)`);
-      }
-      let repoId = str2(flags["repo"]);
-      let created = false;
-      if (!repoId) {
-        const grants = [];
-        const repo = await p.createRepository({ name: str2(flags["name"]) ?? dir.split("/").pop() ?? "", grants });
-        repoId = repo.repoId;
-        created = true;
-      } else {
-        await p.getRepository(repoId);
-      }
-      await p.associate(dir, repoId);
-      const workspace = await p.adoptWorkspace(dir).catch(() => null);
-      out({
-        ok: true,
-        repoId,
-        created,
-        endpoint,
-        dir,
-        onboarding: onboarding ? { commit: onboarding.commit, committed: onboarding.committed.length, excluded: onboarding.excluded } : null,
-        workspace: workspace === null ? null : { branch: workspace.branch, baseOid: workspace.baseOid, baseGeneration: workspace.baseGeneration }
-      });
+      const repo = str2(flags["repo"]);
+      const linked = await linkFolder(p, endpoint, dir, repo ? { repoId: repo } : {});
+      out({ ok: true, ...linked, endpoint, dir });
       return 0;
     }
     case "publish": {
@@ -6457,19 +6555,21 @@ Waiting (it expires in ${Math.round(expiresInSeconds / 60)} minutes)...
     }
     /**
      * The creator's one verb: record the folder's changes, bring in what the service has, publish.
-     * `--apply` is what this was before it recorded and published, and is still accepted, so a
-     * `sync --apply` written down anywhere does the whole round trip rather than failing.
+     * `--apply` is still accepted, so a `sync --apply` written down anywhere does the whole round
+     * trip rather than failing.
      */
     case "sync": {
       const dir = dirArg(1);
       const timeoutMs = followTimeoutMs(str2(flags["timeout"]));
       const { p, endpoint } = await client(dir);
+      const linked = await isGitRepo(dir) && await readAssociation(dir) !== null ? null : await linkFolder(p, endpoint, dir, {});
       const r = await p.syncChanges({ directory: dir, markConflicts: flags["mark-conflicts"] === true, ...optStr(flags, "message") }, { onProgress: progress });
       const o = r.published;
       const followed = o !== null && o.state === "accepted" && flags["no-wait"] !== true ? await followPublication(p, endpoint, o, { onStage: emitStage, log, timeoutMs }) : null;
       out({
         ok: r.state === "published" || r.state === "up_to_date",
         state: r.state,
+        linked: linked === null ? null : { repoId: linked.repoId, appId: linked.appId, created: linked.created },
         recorded: r.recorded,
         merged: r.reconciled.applied,
         conflicts: r.reconciled.before.conflicts,

package/package.json

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