synthesisui 0.16.424 → 0.16.426

package/dist/commands/autopilot.js

@@ -0,0 +1,167 @@
+import { resolve } from "node:path";
+import { readToken, resolveRegistry } from "../config.js";
+import { installedSlugs } from "../installed.js";
+import { body, paint, section } from "../output.js";
+const isState = (x) => !!x &&
+    typeof x === "object" &&
+    typeof x.on === "boolean" &&
+    typeof x.landsOn === "string";
+/**
+ * O ESTADO, EM UMA LINHA - e o nome do sistema junto, porque um repo pode ter dois.
+ *
+ * O SLUG É O LOCAL, NUNCA O QUE VOLTOU DA REDE - achado da revisão de QA no fecho. Ele é a
+ * PERGUNTA, não a resposta: num repo com dois sistemas instalados, uma resposta que trouxesse
+ * outro nome faria o terminal dizer que mudou o sistema em que ela não mexeu. A lei de imprimir o
+ * lido de volta vale para o ESTADO, que é o que a rota decide.
+ */
+const stateLine = (s, slug) => `Autopilot is ${s.on ? "on" : "off"} for you in ${slug}.`;
+/**
+ * POR QUE ELE ESTÁ ASSIM - e as três respostas são coisas diferentes.
+ *
+ * `unavailable` é a lacuna declarada: dizer "alguém te desligou" sobre uma tabela que aquele banco
+ * ainda não tem é falso duas vezes - ninguém desligou, e o que houve foi uma leitura que não
+ * respondeu. Lacuna calada é bug (lei 8).
+ */
+const whyLine = (s) => s.why === "chosen"
+    ? `you switched this ${s.on ? "on" : "off"} yourself, and it stands even if the system default changes.`
+    : s.why === "default"
+        ? "you have no choice of your own here, so the system default answers for you."
+        : "per-person Autopilot has not reached this system yet, so nobody switched you off - off is the honest answer until it does.";
+/** Onde o trabalho dela cai - a segunda pergunta de quem acabou de mudar a automação. */
+const landsLine = (s, base, slug) => s.landsOn === "branch"
+    ? `your work lands in YOUR branch, not on the main line your team installs - it reaches them when whoever owns this system approves it: ${base}/dashboard/mine/${slug}`
+    : "your work goes straight to the main line your team installs.";
+function say(s, base, slug) {
+    console.log(section("Autopilot"));
+    console.log(body(paint.strong(stateLine(s, slug))));
+    console.log(body(paint.dim(whyLine(s))));
+    console.log(body(paint.dim(landsLine(s, base, slug))));
+    console.log("");
+}
+export async function autopilot(opts) {
+    const root = resolve(opts.dir ?? process.cwd());
+    const base = resolveRegistry(opts.registry);
+    const asked = opts.wanted?.trim().toLowerCase();
+    /**
+     * A PALAVRA É CONFERIDA ANTES DE QUALQUER IDA À REDE - e antes do login, inclusive. Mandar
+     * `maybe` para o servidor e deixá-lo recusar gastaria uma volta para dizer o que já se sabe
+     * aqui, e devolveria a ela uma frase sobre a rota em vez das duas escolhas que existem.
+     */
+    if (asked && asked !== "on" && asked !== "off") {
+        console.log(section("Autopilot"));
+        console.log(body(`"${opts.wanted}" is not a choice here. The two are: ${paint.strong("on")} and ${paint.strong("off")}.`));
+        console.log(body(paint.faint("    synthesisui autopilot        # what it is right now, without changing it")));
+        /**
+         * E ELE SAI COM FALHA - achado da revisão de QA no fecho: um script que roda
+         * `synthesisui autopilot $CHOICE` com a variável vazia ou com um valor digitado errado
+         * seguiria como se tivesse mudado. É a mesma lei do 403, e o caminho mais provável de chegar
+         * aqui é justamente automação, não uma pessoa digitando.
+         */
+        process.exitCode = 1;
+        return;
+    }
+    const token = await readToken(opts.home);
+    if (!token) {
+        console.log(section("Autopilot"));
+        console.log(body("Not logged in, so there is nothing to read here - this switch is yours on the platform, not a file in this clone:"));
+        console.log(body(paint.blue("    synthesisui login")));
+        return;
+    }
+    /**
+     * QUAL SISTEMA - o `.lock` é o que diz qual slug este repositório alimenta.
+     *
+     * Num repo com dois, ele age no primeiro em ordem alfabética, e a saída NOMEIA qual: um comando
+     * que age calado sobre "o primeiro" é um comando que ela não tem como conferir.
+     */
+    const installed = await installedSlugs(root);
+    const slug = installed[0];
+    if (!slug) {
+        console.log(section("Autopilot"));
+        console.log(body("No installed system here, so there is no Autopilot to read. Install the one this repo follows first:"));
+        console.log(body(paint.blue("    npx synthesisui@latest add <slug>")));
+        console.log(body(paint.faint("    npx synthesisui@latest list --mine    # the slugs you own")));
+        return;
+    }
+    const url = `${base}/api/registry/ds/${slug}/autopilot`;
+    const auth = { authorization: `Bearer ${token}` };
+    /** A leitura, e ela é a mesma nos dois caminhos - perguntar, e dizer o que continua valendo. */
+    const read = async () => {
+        const res = await fetch(url, { headers: auth });
+        if (!res.ok)
+            return null;
+        const data = (await res.json().catch(() => null));
+        return isState(data) ? data : null;
+    };
+    const unreachable = (why) => {
+        console.log(section("Autopilot"));
+        console.log(body(`This machine could not reach the platform, so nothing was read and nothing was changed: ${base}${why instanceof Error ? ` (${why.message})` : ""}. Try again when you are back online, or point it at the right place with --registry <url>.`));
+        process.exitCode = 1;
+    };
+    if (!asked) {
+        try {
+            const now = await read();
+            if (!now) {
+                console.log(section("Autopilot"));
+                console.log(body(`${paint.strong(slug)} did not answer for this account at ${base}. If your session is old, log in again: ${paint.blue("synthesisui login")}`));
+                process.exitCode = 1;
+                return;
+            }
+            say(now, base, slug);
+        }
+        catch (error) {
+            unreachable(error);
+        }
+        return;
+    }
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ choice: asked }),
+        });
+        if (res.status === 403) {
+            /**
+             * A RECUSA VEM DO SERVIDOR, INTEIRA - ela nomeia o papel que resolve, e é isso que separa
+             * "não deu" de "fale com quem administra as pessoas deste grupo".
+             */
+            const said = (await res.json().catch(() => null));
+            console.log(section("Autopilot"));
+            console.log(body(said?.error ??
+                "That is not yours to change here, and the server did not say who it belongs to."));
+            process.exitCode = 1;
+            /** E O QUE CONTINUA VALENDO, porque uma recusa sem o estado deixa ela sem saber onde está. */
+            const now = await read().catch(() => null);
+            if (now)
+                say(now, base, slug);
+            return;
+        }
+        if (res.status === 404) {
+            console.log(section("Autopilot"));
+            console.log(body(`${paint.strong(slug)} does not reach this account at ${base}, so there is nothing to change here. If your session is old, log in again: ${paint.blue("synthesisui login")}`));
+            process.exitCode = 1;
+            return;
+        }
+        if (!res.ok) {
+            console.log(section("Autopilot"));
+            console.log(body(`${base} answered ${res.status} to that, so nothing was changed. Nothing of yours was lost.`));
+            process.exitCode = 1;
+            return;
+        }
+        /**
+         * O ESTADO IMPRESSO É O QUE A ROTA RELEU DO BANCO depois de escrever - nunca o que este
+         * processo pediu. Ver o cabeçalho: um interruptor que parece ligado e não está é pior que um
+         * que recusa.
+         */
+        const now = (await res.json().catch(() => null));
+        if (!isState(now)) {
+            console.log(section("Autopilot"));
+            console.log(body(`${base} answered something this version cannot read, so it is not saying what the switch is now. Upgrade and try again: npx synthesisui@latest autopilot`));
+            process.exitCode = 1;
+            return;
+        }
+        say(now, base, slug);
+    }
+    catch (error) {
+        unreachable(error);
+    }
+}

package/dist/commands/sync.js

@@ -42,6 +42,21 @@ import { resolveReadParts, siblingProjects, takeCensus, } from "./import.js";
 export function draftLine(slug, base) {
     return `this went into your DRAFT - your repository still has what you installed. It reaches the disk once you publish${base ? `: ${base}/dashboard/mine/${slug}/publish` : ""}\n      then: npx synthesisui@latest upgrade ${slug}`;
 }
+/**
+ * O TRABALHO DELA FOI PARA A RAMIFICAÇÃO DELA, E ISSO SE DIZ - `INV-BRANCH-02`.
+ *
+ * O QUE O CLIENTE VIA SEM ISTO: `62 of 62 components written.` - a mesma frase de quem move a
+ * linha principal. Ela fecharia o terminal achando que o time recebeu, e descobriria o contrário
+ * num dia em que estivesse contando com aquilo. É a lacuna calada que a lei 8 proíbe: o cliente
+ * perdoa o que a gente diz que não faz, e não perdoa descobrir sozinho.
+ *
+ * A FRASE DIZ TRÊS COISAS, nesta ordem: onde o trabalho está, que ele está inteiro, e o que falta
+ * para alcançar o time. Sem a terceira ela é um aviso sem saída - e quem lê não tem o que fazer
+ * com ele.
+ */
+export function branchLine(slug, base) {
+    return `this went to YOUR branch, not to the main line your team installs - nothing of it was lost. It reaches them when whoever owns this system approves it${base ? `: ${base}/dashboard/mine/${slug}` : ""}`;
+}
 export function decisionLine(d, slug, 
 /** Onde o sistema dele vive - o `publish` mora lá, e sem o endereço a frase manda procurar. */
 base) {
@@ -629,6 +644,12 @@ export async function remeasure(args) {
     console.log("");
     console.log(section("Sent"));
     console.log(body(`${out.written ?? 0} of ${out.total ?? 0} components written.`));
+    /**
+     * E ONDE ELE CAIU, logo abaixo do número - porque é o número que ela leria como "o time
+     * recebeu".
+     */
+    if (out.landedOn === "branch")
+        console.log(body(paint.strong(branchLine(slug, base))));
     /**
      * O QUE VEIO DOS ARQUIVOS DELE, DITO - e antes de qualquer outra nota, porque é a única parte
      * desta saída que fala do trabalho que ELE acabou de fazer.

package/dist/index.js

@@ -8,6 +8,7 @@ import { add } from "./commands/add.js";
 import { adopt } from "./commands/adopt.js";
 import { advise } from "./commands/advise.js";
 import { align } from "./commands/align.js";
+import { autopilot } from "./commands/autopilot.js";
 import { ci } from "./commands/ci.js";
 import { clean } from "./commands/clean.js";
 import { component } from "./commands/component.js";
@@ -88,6 +89,11 @@ Usage - governance (deterministic, FREE):
                                            declare, and says what it offers instead. create: it
                                            reports and gets out of the way. No argument answers
                                            where you are. Local to this clone, never committed
+  synthesisui autopilot [on|off]           the Autopilot, FOR YOU in this system: on applies what it
+                                           finds on your work without asking, off stops it acting
+                                           for you - your sync still goes up either way. No argument
+                                           answers where you are, and it always says which line your
+                                           work is landing in
   synthesisui hook                         the check itself; installed by connect, run by your editor
   synthesisui mcp                          the system as tools; installed by connect, run by your agent
 
@@ -286,6 +292,20 @@ async function main() {
         case "mode":
             await mode({ dir, ...(args[0] ? { wanted: args[0] } : {}) });
             break;
+        /**
+         * O INTERRUPTOR DELA NA PLATAFORMA - ver `autopilot.ts`.
+         *
+         * O irmão de `mode`, e a diferença importa: `mode` é local a este clone, e este muda um estado
+         * que mora no servidor e que a tela de configurações mexe pela outra porta. Sem argumento ele
+         * RESPONDE, pela mesma razão dos dois.
+         */
+        case "autopilot":
+            await autopilot({
+                dir,
+                registry,
+                ...(args[0] ? { wanted: args[0] } : {}),
+            });
+            break;
         // Long-lived: it owns stdin/stdout until the client closes the pipe, so
         // it must not be reached by anything that prints.
         case "mcp":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.424",
+  "version": "0.16.426",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {