@arkvenai/cli 0.5.1 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @arkvenai/cli
 
-Dein Arkven-Projekt auf diesem Rechner: anmelden, holen, ändern, zurückstellen, online stellen.
+Dein Arkven auf diesem Rechner: anmelden, Quelltext holen, ändern, zurückgeben, live schalten.
 
 ```bash
 npm install -g @arkvenai/cli
@@ -11,294 +11,132 @@ Ohne Installation läuft jeder Befehl auch als `npx @arkvenai/cli <befehl>`.
 
 ---
 
-## Weg 1: eine App, die es in Arkven schon gibt
+## Ab 0.6.0: welcher Server
 
-Der Normalfall. Du hast im Cockpit gebaut und willst lokal weiterarbeiten.
+**0.6.0 spricht das heutige Arkven** unter `app.arkven.de`. Wer noch das alte System unter
+`de.arkven.de` benutzt, bleibt auf `0.5.1` — die Wege dorthin heißen anders, und eine Fassung, die
+beide bedient, bräuchte einen Schalter, der sich durch jeden Befehl zöge.
 
 ```bash
-arkven login                  # 1. einmal pro Rechner
-mkdir meine-app && cd meine-app
-arkven pull                   # 2. zeigt deine Projekte, du wählst die Nummer
-                              # 3. Änderungen machen: Editor, Agent, wie du willst
-arkven push                   # 4. Vorschau ansehen und bestätigen
-arkven push --deploy          # 5. online stellen
-```
-
-**Schritt 2 sieht so aus:**
-
-```
-$ arkven pull
-
-Dieser Ordner kennt noch kein Projekt. Deine Projekte:
-
-   1  Mein Laden                        live   zuletzt 25.08.2026
-      sess_cf86fd83-6f68-45fa-8c9d-0399a3eb6caf
-   2  Touren-Planer                            zuletzt 20.08.2026
-      sess_9rxa9vk
-
-Welches Projekt? [1-2] >
+npm install -g @arkvenai/cli@0.5.1   # nur für de.arkven.de
 ```
 
-Danach steht die Kennung in `arkven.json`, und jeder weitere `pull` und `push` in diesem Ordner
-meint dieses Projekt. Ohne Rückfrage: `arkven pull --projekt=<kennung>`.
-
-Von da an ist der Rundlauf immer derselbe: **ändern, `arkven push`, `arkven push --deploy`.**
-
 ---
 
-## Weg 2: ein Projekt, das auf deinem Rechner entstanden ist
+## Der Rundlauf
 
 ```bash
-arkven login                        # 1. einmal pro Rechner
-cd mein-projekt
-arkven init                         # 2. schreibt arkven.json
-arkven push --name="Mein Tool"      # 3. legt das Projekt in Arkven an
-arkven push --deploy                # 4. online stellen
-```
+arkven login                     # einmal je Rechner, du bestätigst im Browser
+arkven status                    # welche Apps es gibt
 
-Ab dem zweiten Mal genügen `arkven push` und `arkven push --deploy`: Name und Kennung stehen dann in
-`arkven.json`.
+mkdir meine-app && cd meine-app
+arkven pull --app=lb1234abcd     # zeigt erst, was käme
+arkven pull --app=lb1234abcd --ja
 
-Ganz von vorn: `arkven new meine-app` legt ein Projekt an, das die Anforderungen des Containers
-schon erfüllt.
+# ... ändern, wie du willst ...
 
----
+arkven push                      # zeigt, was sich ändern würde
+arkven push --ja                 # überträgt
+arkven live --ja                 # schaltet live
+```
 
-## Die Befehle
+Nach dem ersten `pull` steht die Zuordnung in `arkven.json`, und `push` weiß von selbst, welche App
+gemeint ist.
 
-| Befehl | Was er tut |
-|---|---|
-| `arkven login` | Meldet diesen Rechner an deinem Arkven-Konto an |
-| `arkven pull` | Holt ein Projekt aus Arkven in diesen Ordner |
-| `arkven push` | Stellt deinen Stand zurück nach Arkven |
-| `arkven push --deploy` | Rollt danach aus und zeigt den Lauf mit |
-| `arkven init` | Erkennt, was dein Projekt mitbringt, und schreibt `arkven.json` |
-| `arkven new <name>` | Legt ein neues Projekt an, das den Container-Vertrag schon erfüllt |
-| `arkven check` | Prüft dein Projekt, so oft du willst |
-| `arkven fix` | Übergibt die Befunde dem lokalen Claude Code und misst danach erneut |
-| `arkven mcp` | Meldet `check`, `auftrag` und `pull` als MCP-Werkzeuge an |
-
-`arkven help` zeigt dieselbe Übersicht mit allen Schaltern.
+**Kein Befehl verändert etwas ohne `--ja`.** Ohne die Flagge siehst du nur, was passieren würde.
 
 ---
 
-## `arkven login`
+## Mehrere Umgebungen
 
 ```bash
-arkven login                        # Standard: https://app.arkven.de
-arkven login --server=<adresse>     # eigene Installation
-arkven login --einfuegen            # wenn dieser Rechner den Server nicht erreicht
-```
-
-Der Browser bestätigt, das Token landet im Benutzerverzeichnis (`~/.arkven/zugang.json`), nie im
-Projekt. Die Standard-Adresse ist `app.arkven.de` und nicht `arkven.de`: unter der bloßen Domain
-liegt die Marketing-Seite, die Anwendung samt API liegt unter `app.`.
-
-`login` richtet auch den Paketbezug ein, danach funktioniert `npm install @arkvenai/base` in diesem
-Projekt.
+arkven login                                  # heißt "produktion"
+arkven login --server=https://app.s.arkven.de # heißt "staging"
 
-## `arkven pull`
-
-```bash
-arkven pull                          # zeigt deine Projekte und fragt, welches
-arkven pull --projekt=<kennung>      # ohne Rückfrage, für Skripte
-arkven pull --yes                    # bestätigt die Vorschau ungesehen
-arkven pull --nur-deklaration        # ohne Code: Bauplan, Auftrag, Nachweis, Mail-Vorlagen
+arkven umgebung            # alle, die aktive mit *
+arkven umgebung staging    # umschalten
+arkven status --umgebung=produktion  # einmalig eine andere fragen
 ```
 
-Ein leeres Verzeichnis genügt. Du musst vorher **nicht** gepusht haben. Sitzt niemand am Terminal,
-wird nicht geraten, sondern die Liste ausgegeben und `--projekt=` genannt.
-
-Wo Server und Oberfläche liegen, sagt das Projekt selbst: `pull` trägt seine `arkven.json` nach,
-bevor er ablegt, und legt die genannten Ordner an. Damit bekommst du den Baum, den ein späterer
-`push` wieder erwartet.
+Beide Anmeldungen liegen nebeneinander in `~/.arkven/zugang.json`. Bis 0.5.1 war dort Platz für
+genau eine, und ein Login gegen Staging warf den Produktionszugang weg.
 
-**Es wird nie etwas gelöscht.** Dateien, die nur bei dir liegen, bleiben unberührt. Was
-überschrieben würde, steht einzeln in der Vorschau, bevor irgendetwas passiert.
+Ein `arkven.json` kann seine Umgebung festhalten (`"umgebung": "staging"`), dann gilt für diesen
+Ordner immer sie — auch wenn gerade eine andere aktiv ist.
 
-## `arkven push`
-
-```bash
-arkven push                      # zeigt die Vorschau und fragt
-arkven push --deploy             # danach ausrollen und den Lauf mitlesen
-arkven push --yes                # bestätigt sie ungesehen (CI, Agenten)
-arkven push --name="Mein Tool"   # der Anzeigename beim ersten Mal
-```
-
-Die Reihenfolge ist die Aussage:
-
-1. **Geprüft wird zuerst.** Was den Container-Vertrag nicht hält, wird benannt und nicht
-   übertragen. Die Gates der Plattform laufen dabei mit, dieselbe Prüfung wie beim Ausrollen.
-2. **Gesammelt wird nur Quelltext.** Versteckte Einträge bleiben liegen, also auch `.env` und
-   `.git`: Zugangsdaten verlassen deinen Rechner nicht. Erzeugte Ordner (`node_modules`, `dist`,
-   `build`, `coverage`) ebenfalls nicht. Was ausgelassen wurde, sagt der Lauf mit Zahl.
-3. **Vorschau vor dem Schreiben.**
+---
 
-```
-Vorschau für „Rechnungstool" (sess_a8jan2i)
+## Wenn ein Programm für dich arbeitet
 
-    14 neu           (in deinem Verzeichnis, in Arkven noch nicht)
-     3 aktualisiert  (du hast sie geändert, Arkven nicht)
-    84 unberuehrt    (in Arkven ändert sich daran nichts)
-```
+Läuft in diesem Ordner ein Agent, gib ihm einen Zugang, der **nicht** live schalten kann:
 
-**Bei einem Konflikt bricht `push` ab und nennt die Dateien.** Es gibt bewusst kein `--force`, und
-auch `--yes` löst keinen Konflikt auf: eine automatische Wahl würde eine der beiden Fassungen still
-verlieren, und das sähe aus wie ein gelungener Push.
+Arkven öffnen → **Zugänge** → **Zugang anlegen** → *Ansehen und Quelltext übertragen*.
 
-Ein Push löscht nichts, was nur Arkven kennt: der erzeugte Server bleibt stehen. Ein abgebrochener
-Lauf (Strg-C, Netz weg) hinterlässt kein halbes Projekt, angelegt wird erst nach vollständiger
-Übertragung.
+Der darf holen und übertragen. Das Live-Schalten bleibt bei dir: du siehst dir den Stand in Arkven
+an und entscheidest. Ein Zugang aus `arkven login` kann beides — den holst du dir für dich, nicht
+für ein Programm.
 
-`--deploy` ruft dieselbe Route wie die Oberfläche und mit derselben Rollenprüfung. Scheitert der
-Lauf, steht die **erste** Fehlerzeile oben, und dein Code bleibt übertragen.
+| | ansehen | übertragen | live schalten |
+|---|---|---|---|
+| Zugang „Nur ansehen" (7 Tage) | ja | nein | nein |
+| Zugang „übertragen" (1 Tag) | ja | ja | **nein** |
+| `arkven login` (30 Tage) | ja | ja | ja |
 
-### Der Name wird nicht geraten
+---
 
-Beim ersten Push heißt das Projekt so, wie `--name` es sagt; ohne die Angabe gilt der `name` aus
-der `package.json` der Projektwurzel, danach der Name der Wurzel selbst. Sagt keiner davon etwas
-über das Projekt (`server`, `app`, `src` …), wird gefragt. Gibt es kein Terminal, bricht der Lauf ab
-und nennt `--name` als Weg. Aus einem Ordnernamen wurde schon einmal ein Projekt namens „server".
+## Was mitgeht und was nicht
 
-### Zwei Teile: Server und Frontend in getrennten Ordnern
+`arkven push` schickt den Quelltext dieses Ordners. Draußen bleiben `node_modules`, `dist`, `build`,
+`.git`, `.next`, `.cache`, `coverage` — und **`.env`**, weil dort Geheimnisse stehen. Eine
+`.env.example` geht mit.
 
-Arkven hält ein Projekt an **zwei** Orten, und sie haben verschiedene Aufgaben: aus dem
-Frontend-Teil entstehen Vorschau und Frontend-Bau, der Server-Teil geht in den Container. Liegen
-beide bei dir in eigenen Ordnern, sagt das `arkven.json`:
+Bilder, Schriften und Videos gehen diesen Weg nicht; die Ausgabe sagt, wie viele übersprungen wurden.
 
-```jsonc
-{
-  "verzeichnisse": {
-    "server": "server",   // geht in den Container
-    "frontend": "web"     // wird die Vorschau
-  }
-}
-```
+**Ein Push löscht nichts.** Was in Arkven liegt und nicht mitkommt, bleibt liegen — die Vorschau
+sagt, wie viele das sind. Wer eine Datei loswerden will, entfernt sie in Arkven.
 
-Beide Angaben sind optional und relativ zur Projektwurzel. Ohne sie ist die Projektwurzel der eine
-Baum. Mit der Angabe gilt:
-
-- **Beide Bäume werden gesammelt**, jeder mit Pfaden relativ zu seinem Verzeichnis: aus
-  `web/src/App.tsx` wird `/src/App.tsx` in der App, aus `server/src/index.ts` wird `src/index.ts`
-  im Server-Quelltext. Der Bericht sagt vor dem Schreiben, welche Datei wohin geht.
-- **Geprüft wird der Server-Teil**, nicht die Wurzel.
-- **`arkven.json` reist mit dem Frontend-Teil.** Der Bau liest deine `mitgebracht`-Angaben dort;
-  ohne diesen Schritt käme deine eigene `tailwind.config.js` unter das Scaffold.
-- **Was außerhalb beider Ordner liegt, kommt nicht mit** und wird beim Namen genannt. Braucht ein
-  Teil einen gemeinsamen `shared/`-Ordner, muss er innerhalb seines Verzeichnisses liegen.
-
-Ein Verzeichnis, das es nicht gibt, bricht den Lauf ab, statt still auf „ein Baum" zurückzufallen:
-genau dieser stille Rückfall hat am 2026-08-01 einen Express-Server in die Frontend-Vorschau
-gelegt. Das Ergebnis war eine leere Seite und die Frage „wo ist mein Frontend?".
-
-## `arkven init`
-
-`init` liest, was da ist (`package.json`, Lockfile, eigener Server, `drizzle/`-Historie,
-Build-Setup) und schreibt **eine** Datei: `arkven.json`.
-
-```jsonc
-{
-  "$schema": "https://app.arkven.de/schema/arkven.json",
-  "mitgebracht": {
-    "server": true,         // Arkven ergänzt, es scaffoldet nicht
-    "frontendBuild": false, // tailwind/postcss/vite bleiben deine
-    "schema": true          // deine Migrationen gewinnen
-  }
-}
-```
+---
 
-**Was nicht sicher erkennbar ist, wird gefragt**, mit Vorschlag, nie geraten. Gibt es kein Terminal
-(Skript, CI, Pipe), bleibt das Feld aus der Datei heraus und der Lauf sagt, welches und warum. Ein
-geratenes `server: true` hieße später: Arkven ergänzt einen Server, den es nie gab.
+## Wenn etwas nicht geht
 
-**Was fehlt, kommt als Diff zum Bestätigen**, nie als stille Schreibaktion: eine
-`schemaGate.ts`-Vorlage, `tsx`/`drizzle-kit` in den `dependencies`, `.gitignore`-Einträge.
-`arkven init --apply` übernimmt die Datei-Vorschläge gesammelt. Alles, was Pakete aus dem Netz holt,
-bleibt ein Befehl für dich.
+| Meldung | Was zu tun ist |
+|---|---|
+| „Auf diesem Rechner ist noch keine Umgebung angemeldet" | `arkven login` |
+| „Der Zugang für … ist abgelaufen" | `arkven login --umgebung=<name>` |
+| „Dieser Ordner gehört zu keiner App" | `arkven pull --app=<kennung>`, Kennungen zeigt `arkven status` |
+| „Dieser Zugang darf Quelltext übertragen, aber nicht live schalten" | So ist er gemeint. Live schalten in Arkven, oder mit einem Zugang aus `arkven login` |
+| „An dieser App arbeitet gerade der Agent" | Warten, bis der Lauf durch ist |
 
-Die Datei gehört dir. Steht ein Feld schon drin, bleibt es stehen, auch wenn die Messung etwas
-anderes sagt; der Unterschied wird benannt statt überschrieben. Ein zweiter Lauf ändert nichts, was
-der erste richtig gemacht hat, und formatiert deine `package.json` nicht um.
+---
 
-## `arkven new`
+## Alle Befehle
 
-```bash
-arkven new meine-app
-cd meine-app && npm install
 ```
-
-Legt 15 Dateien an und misst danach selbst nach: **9 gehalten, 0 blockierend**, bevor die erste
-eigene Zeile geschrieben ist.
-
-| Was | Wo | Wogegen es hilft |
-|---|---|---|
-| Einstieg mit Härtungs-Prüfung beim Start | `src/index.ts` | Fällt ein Pflicht-Header beim Umbau heraus, bricht der Start ab, statt still ungehärtet zu laufen |
-| Wächter gegen die laufende Datenbank | `src/schemaGate.ts` | Eine Migration kann mit Rückgabewert 0 enden, ohne dass das Schema steht |
-| Eine Egress-Naht mit Host-Allowlist | `src/lib/egress.ts` | „Mit wem redet diese App?" hat genau eine Antwort |
-| Härtung ohne Importe | `src/http/sicherheitsHeader.ts` | Läge sie im Einstieg, entstünde ein Import-Zyklus über die Middleware |
-| Migration **und** Journal | `drizzle/` | Ohne Journal legt der Container das Schema neu an, statt zu migrieren |
-| `tsx` und `drizzle-kit` in `dependencies` | `package.json` | Der Container installiert nur `dependencies` |
-
-`arkven.json` entsteht dabei über dieselbe Erkennung wie bei `init`, nicht über eine zweite Regel.
-
-**Es wird nie etwas überschrieben.** Liegt im Zielverzeichnis schon etwas, bricht der Lauf ab und
-nennt beide Auswege (anderer Name oder `arkven init`). Ein leeres Verzeichnis darf er benutzen.
-
-## `arkven check`
-
-```bash
-arkven check           # lokal, in Sekunden
-arkven check --tief    # die Gates der Plattform laufen mit (braucht Anmeldung)
-arkven check --json    # stabile Regel-Kennungen, für Agenten
-arkven check --sarif   # SARIF 2.1.0 für GitHub Code-Scanning, VS Code und CI
+arkven login [--server=<adresse>] [--umgebung=<name>]
+arkven status [--umgebung=<name>]
+arkven umgebung [<name>] [--weg=<name>]
+arkven pull [--app=<kennung>] [--ja]
+arkven push [--betreff="..."] [--ja]
+arkven live [--ja]
 ```
 
-Jeder Befund nennt Datei, Regel und Ausweg. Geprüft wird:
+`--umgebung=<name>` geht überall, wenn nicht die aktive gemeint ist.
 
-| Regel | Was gilt |
-|---|---|
-| `arkven/ein-paket` | Das Verzeichnis ist ein Paket, kein Verbund aus mehreren |
-| `arkven/einstieg` | `src/index.ts` ist der Einstiegspunkt |
-| `arkven/port-aus-umgebung` | Der Port kommt aus `process.env.PORT` |
-| `arkven/datenbank-aus-umgebung` | Die Verbindung kommt aus `process.env.DATABASE_URL` |
-| `arkven/keine-workspaces` | Eine `package.json`, keine Workspace-Verweise |
-| `arkven/importe-aufloesbar` | Jeder Import zeigt auf ein Paket, das im Container existiert |
-| `arkven/laufzeit-tsx` · `arkven/laufzeit-drizzle-kit` | Beide stehen in `dependencies`, nicht in `devDependencies` |
-| `arkven/schema-waechter` | `src/schemaGate.ts` prüft das Schema gegen die laufende Datenbank |
-
-Dazu zwei Hinweise, die nicht blockieren: ein fehlendes Migrations-Journal
-(`arkven/migrations-journal`) und fehlender Baustein-Bezug (`arkven/paketbezug`).
+---
 
-**Monorepos:** Zeigst du auf ein Verzeichnis mit mehreren Paketen, meldet der Lauf **eine** Sache
-statt sieben: der Container macht genau ein Paket zur App, also ist erst zu klären, welches. Die
-übrigen Punkte erscheinen als „nicht geprüft", nicht als verletzt. Der Ausweg nennt die Kandidaten.
+## Für den Betrieb: veröffentlichen
 
-## `arkven fix`
+Das Konto `arkvenai` steht auf `two-factor auth: auth-and-writes`, und es gibt kein
+Authenticator-Programm. Deshalb geht das Veröffentlichen **nur aus einem echten
+Konsolenfenster**: ohne stdin-TTY bietet npm den Browser-Weg gar nicht erst an und bricht mit
+`EOTP` ab. Aus einer Werkzeug-Shell heraus also nie.
 
-```bash
-arkven fix              # höchstens 3 Durchgänge, `--runden N` für mehr
-arkven auftrag          # gibt nur die Arbeitsanweisung aus, ohne etwas zu tun
+```powershell
+Start-Process cmd.exe -ArgumentList '/k','cd /d C:\Users\Pflegehilfe\Desktop\Sortieren\Regugate\lean-builder\cli && npm run veroeffentlichen'
 ```
 
-`fix` baut aus jedem blockierenden Befund einen Auftrag und übergibt ihn dem **lokal installierten
-Claude Code** (dessen Konto, dessen Rechte, dessen Abrechnung, kein eigener Schlüssel). Danach misst
-es erneut.
-
-Die tragende Regel: **behoben ist nur, was der erneute Lauf misst.** Die Erfolgsmeldung des Agenten
-zählt nichts. Bringt eine Runde keinen einzigen Punkt weiter, hört `fix` auf, statt dieselbe
-Anweisung zu wiederholen. Es committet nichts und pusht nichts; die Änderungen liegen als `git diff`
-zur Durchsicht. Ist kein `claude` installiert, sagt `fix` das und nennt den Weg.
-
----
-
-## Rückgabewerte
-
-| Befehl | `0` | `1` | `2` |
-|---|---|---|---|
-| `check` | alles gehalten | mindestens ein blockierender Punkt | nichts messbar |
-| `init` | alles geklärt | etwas bleibt zu entscheiden | nichts messbar |
-| `new` | angelegt und nachgemessen | abgebrochen, nichts angelegt | |
-| `push` | übernommen | Befund oder Konflikt | nichts messbar |
+**Sobald „Press ENTER to open in the browser" erscheint: ENTER im Fenster drücken**, nicht selbst
+zum Browser wechseln. Genau daran ist der Lauf zu 0.5.0 gescheitert.
 
-`--json` liefert dieselben Befunde mit stabilen Regel-Kennungen, damit ein Agent ohne Textanalyse
-handeln kann.
+Danach gegenprüfen, und zwar mit Abstand: `npm view @arkvenai/cli version` liest aus einem CDN und
+zeigt direkt nach dem Upload noch den alten Stand. Eine Minute warten, dann fragen.

package/dist/befehle.js

@@ -1,77 +1,138 @@
-export const BEFEHLE = [
-    {
-        name: 'new',
-        stelle: '<name>',
-        wirkung: 'Legt ein neues Projekt an, das den Container-Vertrag schon erfüllt',
-        schalter: [],
-    },
-    {
-        name: 'init',
-        stelle: '[verzeichnis]',
-        wirkung: 'Erkennt, was das Projekt mitbringt, und schreibt arkven.json',
-        schalter: [{ flagge: '--apply', wirkung: 'Übernimmt die vorgeschlagenen Dateien gesammelt' }],
-    },
-    {
-        name: 'check',
-        stelle: '[verzeichnis]',
-        wirkung: 'Prüft das Projekt gegen den Container-Vertrag',
-        schalter: [
-            { flagge: '--tief', wirkung: 'Lässt die Gates der Plattform mitlaufen (braucht Anmeldung)' },
-            { flagge: '--json', wirkung: 'Maschinenlesbar, mit stabilen Regel-Kennungen' },
-            { flagge: '--sarif', wirkung: 'SARIF 2.1.0 für GitHub Code-Scanning, VS Code und CI' },
-        ],
-    },
-    {
-        name: 'auftrag',
-        stelle: '[verzeichnis]',
-        wirkung: 'Gibt die Arbeitsanweisung aus, ohne etwas zu tun',
-        schalter: [],
-    },
-    {
-        name: 'fix',
-        stelle: '[verzeichnis]',
-        wirkung: 'Übergibt sie dem lokalen Claude Code und misst danach erneut',
-        schalter: [{ flagge: '--runden N', wirkung: 'Höchstens N Durchgänge (Standard 3)' }],
-    },
-    {
-        name: 'login',
-        stelle: '',
-        wirkung: 'Meldet diesen Rechner an deinem Arkven-Konto an',
-        schalter: [
-            { flagge: '--server=<adresse>', wirkung: 'Andere Arkven-Adresse (Standard: https://app.arkven.de)' },
-            { flagge: '--einfuegen', wirkung: 'Wert von der Bestätigungsseite einfügen (wenn dieser Rechner den Server nicht erreicht)' },
-        ],
-    },
-    {
-        name: 'pull',
-        stelle: '[verzeichnis]',
-        wirkung: 'Holt den Stand aus Arkven zurück: Code (Backend und Frontend), dazu Bauplan, Auftrag, ' +
-            'Nachweis, eigene Mail-Vorlagen und die Dokumente des Teams (nach arkven/dokumente/)',
-        schalter: [
-            { flagge: '--yes', wirkung: 'Bestätigt die Vorschau ohne Rückfrage' },
-            { flagge: '--nur-deklaration', wirkung: 'Ohne Code, nur Bauplan, Auftrag, Nachweis, Mail-Vorlagen' },
-            { flagge: '--projekt=<kennung>', wirkung: 'Nennt das Projekt. Ohne diese Angabe zeigt pull deine Projekte zur Auswahl' },
-        ],
-    },
-    {
-        name: 'push',
-        stelle: '[verzeichnis]',
-        wirkung: 'Zeigt erst, was passieren würde, und stellt es dann online',
-        schalter: [
-            { flagge: '--yes', wirkung: 'Bestätigt die Vorschau ohne Rückfrage (für CI und Agenten)' },
-            { flagge: '--deploy', wirkung: 'Rollt nach der Übernahme aus und zeigt den Lauf' },
-            { flagge: '--name=<name>', wirkung: 'Anzeigename beim ersten Mal (sonst: der name aus der package.json, sonst der Name der Projektwurzel; steht keiner fest, wird gefragt)' },
-            { flagge: '--server=<adresse>', wirkung: 'Andere Arkven-Adresse' },
-        ],
-    },
-    {
-        name: 'mcp',
-        stelle: '',
-        wirkung: 'Meldet check, auftrag und pull als MCP-Werkzeuge an (stdio). Hinter keinem steht eigener ' +
-            'Code: es sind dieselben Funktionen wie oben. push ist bewusst NICHT dabei.',
-        schalter: [],
-    },
-    { name: 'version', stelle: '', wirkung: 'Fassung anzeigen', schalter: [] },
-    { name: 'help', stelle: '', wirkung: 'Diese Übersicht', schalter: [] },
-];
-//# sourceMappingURL=befehle.js.map
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import * as ablage from './zugang.js';
+import { absage, neuesGeheimnis, ruf, schlafe } from './ruf.js';
+const OK = { code: 0 };
+const FEHLER = { code: 1 };
+// ── login ────────────────────────────────────────────────────────────────────
+function browserOeffnen(url) {
+    const [befehl, args] = process.platform === 'win32'
+        ? ['cmd', ['/c', 'start', '', url]]
+        : process.platform === 'darwin'
+            ? ['open', [url]]
+            : ['xdg-open', [url]];
+    try {
+        const p = spawn(befehl, args, { stdio: 'ignore', detached: true });
+        p.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function login(opts) {
+    const server = (opts.server ?? ablage.STANDARD_SERVER).replace(/\/+$/, '');
+    const name = opts.umgebung ?? ablage.namenVorschlag(server);
+    const { verifier, challenge } = neuesGeheimnis();
+    const start = await ruf(server, '/api/auth/cli/start', { koerper: { challenge, herkunft: `${os.hostname()} (${os.platform()})` } });
+    if (!start.ok) {
+        opts.sage(absage(start));
+        opts.sage(`Pruef die Adresse: ${server}`);
+        return FEHLER;
+    }
+    opts.sage('');
+    opts.sage('  Oeffne diese Seite, um dich anzumelden:');
+    opts.sage(`  ${start.daten.url}`);
+    opts.sage('');
+    opts.sage(`  Dort sollte dieser Code stehen:  ${start.daten.code}`);
+    opts.sage('');
+    browserOeffnen(start.daten.url);
+    opts.sage('  Warte auf die Bestaetigung ...');
+    const bis = start.daten.laeuftAbAm;
+    const abstand = opts.warteMs ?? 2000;
+    while (Date.now() < bis) {
+        await schlafe(abstand);
+        const holen = await ruf(server, '/api/auth/cli/token', { koerper: { anfrage: start.daten.anfrage, verifier } });
+        // 202 heisst "noch niemand hat bestaetigt". Kein Fehler, sondern der Normalfall,
+        // solange der Mensch die Seite noch offen hat.
+        if (!holen.ok && holen.status === 202)
+            continue;
+        if (!holen.ok && holen.status === 0)
+            continue;
+        if (!holen.ok) {
+            opts.sage('');
+            opts.sage(absage(holen));
+            return FEHLER;
+        }
+        const wo = ablage.eintragen(ablage.lesen(), {
+            name,
+            server,
+            token: holen.daten.cliToken,
+            laeuftAbAm: holen.daten.laeuftAbAm.cli,
+            konto: holen.daten.konto,
+            teams: holen.daten.teams,
+            angemeldetAm: Date.now(),
+        });
+        const datei = ablage.schreiben(wo);
+        opts.sage('');
+        opts.sage(`  Angemeldet als ${holen.daten.konto ?? 'dein Konto'} in "${name}".`);
+        opts.sage(`  Der Zugang liegt in ${datei} und gilt 30 Tage.`);
+        opts.sage('');
+        return OK;
+    }
+    opts.sage('');
+    opts.sage('Es kam keine Bestaetigung an, und die Anmeldung ist abgelaufen.');
+    opts.sage('Fang sie neu an: arkven login');
+    return FEHLER;
+}
+// ── umgebung und status ──────────────────────────────────────────────────────
+export function umgebung(opts) {
+    const wo = ablage.lesen();
+    if (opts.weg) {
+        if (!wo.umgebungen.some((u) => u.name === opts.weg)) {
+            opts.sage(`Eine Umgebung "${opts.weg}" ist hier nicht angemeldet.`);
+            return FEHLER;
+        }
+        ablage.schreiben(ablage.entfernen(wo, opts.weg));
+        opts.sage(`"${opts.weg}" ist weg. Der Token auf dem Server gilt weiter, bis du ihn dort entziehst.`);
+        return OK;
+    }
+    if (opts.name) {
+        if (!wo.umgebungen.some((u) => u.name === opts.name)) {
+            const da = wo.umgebungen.map((u) => u.name).join(', ');
+            opts.sage(`Eine Umgebung "${opts.name}" ist hier nicht angemeldet.`);
+            opts.sage(da ? `Angemeldet sind: ${da}.` : 'Melde dich an: arkven login');
+            return FEHLER;
+        }
+        ablage.schreiben({ ...wo, aktiv: opts.name });
+        opts.sage(`Aktiv ist jetzt "${opts.name}".`);
+        return OK;
+    }
+    if (wo.umgebungen.length === 0) {
+        opts.sage('Auf diesem Rechner ist noch keine Umgebung angemeldet.');
+        opts.sage('Melde dich an: arkven login');
+        return OK;
+    }
+    for (const u of wo.umgebungen) {
+        const marke = u.name === wo.aktiv ? '*' : ' ';
+        opts.sage(`${marke} ${u.name.padEnd(12)} ${u.server}   ${ablage.restlaufzeit(u)}`);
+    }
+    return OK;
+}
+export async function status(opts) {
+    const wahl = ablage.waehlen(ablage.lesen(), opts.umgebung);
+    if (!wahl.ok) {
+        opts.sage(wahl.grund);
+        opts.sage(wahl.ausweg);
+        return FEHLER;
+    }
+    const u = wahl.umgebung;
+    opts.sage(`Umgebung  ${u.name}  (${u.server})`);
+    opts.sage(`Konto     ${u.konto ?? 'unbekannt'}`);
+    opts.sage(`Zugang    ${ablage.restlaufzeit(u)}`);
+    const apps = await ruf(u.server, '/api/cli/apps', { token: u.token });
+    if (!apps.ok) {
+        opts.sage('');
+        opts.sage(absage(apps));
+        return FEHLER;
+    }
+    opts.sage('');
+    if (apps.daten.apps.length === 0) {
+        opts.sage('Du hast dort noch keine App.');
+        return OK;
+    }
+    for (const a of apps.daten.apps) {
+        opts.sage(`  ${a.id.padEnd(12)} ${a.name.padEnd(28)} ${a.live ? 'live' : a.status}`);
+    }
+    return OK;
+}