> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Base44 CLI

> Base44-Apps (Projekte) mit dem Base44-CLI-Tool erstellen und verwalten.

<Warning>
  Diese Seite ist Teil eines KI-Coding-Agent-Skills und für Agenten geschrieben, nicht für Menschen. Für die menschenlesbare Base44-Dokumentation siehe die [Entwicklerdokumentation](/developers).
</Warning>

# Base44 CLI

Base44-Apps (Projekte) mit dem Base44-CLI-Tool erstellen und verwalten.

## ⚡ SOFORTIGE HANDLUNG ERFORDERLICH — Lies das zuerst

Dieser Skill aktiviert sich bei jeder Erwähnung von "base44" oder wenn ein `base44/`-Ordner existiert. **Lies keine Dokumentationsdateien und suche nicht im Web, bevor du handelst.**

**Deine erste Aktion MUSS sein:**

1. Prüfe, ob `base44/config.jsonc` im aktuellen Verzeichnis existiert
2. Wenn **JA** (bestehendes Projektszenario):
   * Übergib an den base44-sdk-Skill zur Implementierung
   * Dieser Skill behandelt nur CLI-Befehle (login, deploy, entities push)
3. Wenn **NEIN**, entscheide zwischen zwei Initialisierungspfaden:
   * **Bereitgestellte App** — die Base44-App existiert bereits, weil sie gerade über einen Stripe Projects / projects.dev-Flow bereitgestellt wurde, ODER `BASE44_APP_ID` (oder `BASE44_PROJECTS_BASE44_APP_ID`) ist in der Umgebung oder in einer `.env`/`.env.local`-Datei vorhanden:
     * Führe `npx base44 scaffold` aus, um lokale Dateien für die **bestehende** App einzurichten
     * **Führe NICHT `npx base44 create` aus** — das erzeugt eine zweite, doppelte App. Siehe [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md).
   * **Neues Projekt** — es existiert noch keine App und es wurde keine bereitgestellt:
     * Dieser Skill (base44-cli) übernimmt die Anfrage; führe den Nutzer durch `npx base44 create`
     * Aktiviere base44-sdk noch NICHT

## Kritisch: Nur lokale Installation

Rufe `base44` NIEMALS direkt auf. Die CLI wird lokal als Dev-Abhängigkeit installiert und muss über einen Paketmanager aufgerufen werden:

* `npx base44 <command>` (npm — empfohlen)
* `yarn base44 <command>` (yarn)
* `pnpm base44 <command>` (pnpm)

FALSCH: `base44 login`
RICHTIG: `npx base44 login`

## VERPFLICHTEND: Authentifizierungsprüfung zu Sitzungsbeginn

**KRITISCH**: Ganz zu Beginn jeder KI-Sitzung, in der dieser Skill aktiviert wird, MUSST du:

1. **Authentifizierungsstatus prüfen** durch:
   ```bash theme={null}
   npx base44 whoami
   ```

2. **Wenn der Nutzer eingeloggt ist** (Befehl erfolgreich, zeigt eine E-Mail):
   * Fahre mit der Aufgabe fort

3. **Wenn der Nutzer NICHT eingeloggt ist** (Befehl schlägt fehl oder zeigt einen Fehler):
   * **STOPPE sofort**
   * **Fahre NICHT** mit CLI-Operationen fort
   * **Fordere den Nutzer auf, sich manuell einzuloggen** mit:
     ```bash theme={null}
     npx base44 login
     ```
   ```
   - Warte, bis der Nutzer bestätigt, dass er eingeloggt ist, bevor du fortfährst
   ```

**Diese Prüfung ist verpflichtend und muss vor jedem anderen Base44-CLI-Befehl erfolgen.**

**Über Stripe Projects / projects.dev bereitgestellt?** Wenn die App über diesen Flow bereitgestellt wurde, bezieht die CLI die Authentifizierung aus den Umgebungsvariablen `BASE44_ACCESS_TOKEN` / `BASE44_REFRESH_TOKEN`, die injiziert werden (die `BASE44_PROJECTS_*`-präfixierten Namen werden automatisch normalisiert). In diesem Fall ist `npx base44 whoami` bereits erfolgreich und du brauchst **kein** interaktives `npx base44 login`.

## Überblick

Die Base44-CLI bietet Kommandozeilen-Tools für Authentifizierung, Projekterstellung, Entitätenverwaltung und Deployment von Base44-Anwendungen. Sie ist Framework-agnostisch und funktioniert mit gängigen Frontend-Frameworks wie Vite, Next.js, Create React App, Svelte, Vue und mehr.

## Wann diesen Skill vs base44-sdk verwenden

**Verwende base44-cli, wenn:**

* Du ein **NEUES** Base44-Projekt von Grund auf erstellst
* Du ein Projekt in einem leeren Verzeichnis initialisierst
* Du lokale Dateien für eine **bestehende** App einrichtest, die extern bereitgestellt wurde (z. B. über einen Stripe Projects / projects.dev-Flow) → verwende `scaffold`
* Im Verzeichnis `base44/config.jsonc` fehlt
* Der Nutzer erwähnt: "neues Projekt erstellen", "Projekt initialisieren", "Projekt einrichten", "neue Base44-App starten"
* Du deployst, Entitäten pushst oder dich per CLI authentifizierst
* Du mit CLI-Befehlen arbeitest (`npx base44 ...`)

**Verwende base44-sdk, wenn:**

* Du Funktionen in einem **BESTEHENDEN** Base44-Projekt baust
* `base44/config.jsonc` bereits existiert
* Du JavaScript/TypeScript-Code mit dem Base44-SDK schreibst
* Du Funktionalität, Komponenten oder Features implementierst
* Der Nutzer erwähnt: "implementieren", "Feature bauen", "Funktionalität hinzufügen", "Code schreiben"

**Skill-Abhängigkeiten:**

* `base44-cli` ist eine **Voraussetzung** für `base44-sdk` in neuen Projekten
* Wenn der Nutzer "eine App erstellen" möchte und kein Base44-Projekt existiert, verwende zuerst `base44-cli`
* `base44-sdk` setzt voraus, dass ein Base44-Projekt bereits initialisiert ist

**Statusprüfungs-Logik:**
Vor der Skill-Auswahl prüfe:

* WENN (Nutzer erwähnt "App erstellen/bauen" ODER "Projekt machen"):
  * WENN (`base44/config.jsonc` existiert):
    → Verwende **base44-sdk** (Projekt existiert, Features bauen)
  * SONST WENN (App wurde extern bereitgestellt — `BASE44_APP_ID`/`BASE44_PROJECTS_BASE44_APP_ID` gesetzt oder ein Stripe Projects / projects.dev-Flow ist gerade gelaufen):
    → Verwende **base44-cli** → `npx base44 scaffold` (lokale Dateien für bestehende App einrichten; NICHT `create`)
  * SONST:
    → Verwende **base44-cli** → `npx base44 create` (neue Projektinitialisierung nötig)

## Projektstruktur

Ein Base44-Projekt kombiniert ein standardmäßiges Frontend-Projekt mit einem `base44/`-Konfigurationsordner:

```
my-app/
├── base44/                      # Base44 configuration (created by CLI)
│   ├── config.jsonc             # Project settings, site config
│   ├── .types/                  # Auto-generated TypeScript types (created by `types generate`)
│   │   └── types.d.ts           # Module augmentation for @base44/sdk
│   ├── entities/                # Entity schema definitions
│   │   ├── task.jsonc
│   │   └── board.jsonc
│   ├── functions/               # Backend functions (optional)
│   │   └── my-function/
│   │       └── entry.ts
│   ├── agents/                  # Agent configurations (optional)
│   │   └── support_agent.jsonc
│   └── connectors/              # OAuth connector configurations (optional)
│       └── googlecalendar.jsonc
├── src/                         # Frontend source code
│   ├── api/
│   │   └── base44Client.js      # Base44 SDK client
│   ├── pages/
│   ├── components/
│   └── main.jsx
├── index.html                   # SPA entry point
├── package.json
└── vite.config.js               # Or your framework's config
```

**Wichtige Dateien:**

* `base44/config.jsonc` — Projektname, Beschreibung, Site-Build-Einstellungen
* `base44/entities/*.jsonc` — Datenmodell-Schemas (siehe Abschnitt Entitätsschema)
* `base44/functions/*/entry.ts` — Einstiegspunkt der Backend-Funktion
* `base44/agents/*.jsonc` — Agent-Konfigurationen (optional)
* `base44/.types/types.d.ts` — automatisch generierte TypeScript-Typen für Entitäten, Funktionen und Agenten (erstellt von `npx base44 types generate`)
* `base44/connectors/*.jsonc` — OAuth-Connector-Konfigurationen (optional)
* `src/api/base44Client.js` — vorkonfigurierter SDK-Client zur Frontend-Nutzung

**config.jsonc-Beispiel:**

```jsonc theme={null}
{
  "name": "My App",                    // Required: project name
  "description": "App description",    // Optional: project description
  "entitiesDir": "./entities",         // Optional: default "entities"
  "functionsDir": "./functions",       // Optional: default "functions"
  "agentsDir": "./agents",             // Optional: default "agents"
  "connectorsDir": "./connectors",     // Optional: default "connectors"
  "site": {                            // Optional: site deployment config
    "installCommand": "npm install",   // Optional: install dependencies
    "buildCommand": "npm run build",   // Optional: build command
    "serveCommand": "npm run dev",     // Optional: local dev server
    "outputDirectory": "./dist"        // Optional: build output directory
  }
}
```

**Konfigurationsproperties:**

| Property               | Beschreibung                               | Standard       |
| ---------------------- | ------------------------------------------ | -------------- |
| `name`                 | Projektname (erforderlich)                 | -              |
| `description`          | Projektbeschreibung                        | -              |
| `entitiesDir`          | Verzeichnis für Entitäts-Schemas           | `"entities"`   |
| `functionsDir`         | Verzeichnis für Backend-Funktionen         | `"functions"`  |
| `agentsDir`            | Verzeichnis für Agent-Konfigurationen      | `"agents"`     |
| `connectorsDir`        | Verzeichnis für Connector-Konfigurationen  | `"connectors"` |
| `site.installCommand`  | Befehl zur Installation der Abhängigkeiten | -              |
| `site.buildCommand`    | Befehl zum Bauen des Projekts              | -              |
| `site.serveCommand`    | Befehl zum Ausführen des Dev-Servers       | -              |
| `site.outputDirectory` | Build-Ausgabeverzeichnis für Deployment    | -              |

## Installation

Installiere die Base44-CLI als Dev-Abhängigkeit in deinem Projekt:

```bash theme={null}
npm install --save-dev base44
```

**Wichtig:** Nimm nie eine Version des `base44`-Pakets an oder codiere sie fest. Installiere immer ohne Versionsspezifizierer, um die neueste Version zu erhalten.

Führe Befehle dann mit `npx` aus:

```bash theme={null}
npx base44 <command>
```

**Hinweis:** Alle Befehle in dieser Dokumentation nutzen `npx base44`. Du kannst bei Bedarf auch `yarn base44` oder `pnpm base44` verwenden.

## Globale Option `--app-id`

Die CLI hat eine globale Option `--app-id <id>` für Befehle, die nur einen App-Kontext, aber keine lokalen Projektdateien benötigen.

**Auflösungsreihenfolge:** `--app-id`-Flag → Umgebungsvariable `BASE44_APP_ID` → lokale `base44/.app.jsonc`

Das ist nützlich, wenn du eine App inspizieren oder darauf operieren möchtest, ohne in ein verknüpftes Projektverzeichnis zu wechseln. Häufige Beispiele:

```bash theme={null}
# Run a one-off script against a specific app
cat ./script.ts | npx base44 exec --app-id app_123

# Fetch logs for a deployed app without a local checkout
npx base44 logs --app-id app_123 --level error
```

Verwende `--app-id` für App-bezogene Befehle wie `exec` und `logs`.

Verwende `--app-id` **nicht** für Befehle, die lokale Projektdateien benötigen:

* `base44 create` erstellt eine neue App und lehnt `--app-id` ab
* `base44 dev` läuft aus einem verknüpften lokalen Projekt und lehnt `--app-id` ab
* `base44 deploy` benötigt weiterhin ein lokales Projektverzeichnis, da es lokale Ressourcen liest

## Verfügbare Befehle

### Authentifizierung

| Befehl          | Beschreibung                                         | Referenz                                                                                         |
| --------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `base44 login`  | Bei Base44 mit dem Device-Code-Flow authentifizieren | [auth-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-login.md)   |
| `base44 logout` | Vom aktuellen Gerät abmelden                         | [auth-logout.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-logout.md) |
| `base44 whoami` | Aktuell authentifizierten Nutzer anzeigen            | [auth-whoami.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-whoami.md) |

### Projektmanagement

| Befehl                  | Beschreibung                                                           | Referenz                                                                                                          |
| ----------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `base44 create`         | Ein neues Base44-Projekt aus einem Template erstellen                  | [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) ⚠️ **MUSS GELESEN WERDEN** |
| `base44 scaffold`       | Lokales Projekt für eine bestehende Base44-App scaffolden (per App-ID) | [scaffold.md](https://docs.base44.com/developers/skills/base44-cli/references/scaffold.md)                        |
| `base44 link`           | Ein bestehendes lokales Projekt mit Base44 verknüpfen                  | [link.md](https://docs.base44.com/developers/skills/base44-cli/references/link.md)                                |
| `base44 eject`          | Den Code für ein bestehendes Base44-Projekt herunterladen              | [eject.md](https://docs.base44.com/developers/skills/base44-cli/references/eject.md)                              |
| `base44 dashboard open` | Das App-Dashboard im Browser öffnen                                    | [dashboard.md](https://docs.base44.com/developers/skills/base44-cli/references/dashboard.md)                      |

### Entwicklung

| Befehl       | Beschreibung                                                                                                               | Referenz                                                                         |
| ------------ | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `base44 dev` | Lokale Entwicklung für dein Base44-Backend starten und, falls `site.serveCommand` konfiguriert ist, auch für dein Frontend | [dev.md](https://docs.base44.com/developers/skills/base44-cli/references/dev.md) |

### Deployment

| Befehl          | Beschreibung                                                                                       | Referenz                                                                               |
| --------------- | -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| `base44 deploy` | Alle Ressourcen deployen (Entitäten, Funktionen, Agenten, Connectors, Auth-Konfiguration und Site) | [deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/deploy.md) |

### Entitätsverwaltung

| Aktion / Befehl        | Beschreibung                                     | Referenz                                                                                                                |
| ---------------------- | ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| Entitäten erstellen    | Entitäten im Ordner `base44/entities` definieren | [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md)                |
| `base44 entities push` | Lokale Entitäten zu Base44 pushen                | [entities-push.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-push.md)                    |
| RLS-Muster             | Row-Level-Security-Beispiele und -Operatoren     | [rls-examples.md](https://docs.base44.com/developers/skills/base44-cli/references/rls-examples.md) ⚠️ **FÜR RLS LESEN** |

#### Entitäts-Schema (Schnellreferenz)

Folge beim Erstellen von Entitätsdateien IMMER dieser exakten Struktur:

**Dateiname:** `base44/entities/{kebab-case-name}.jsonc` (z. B. `team-member.jsonc` für `TeamMember`)

**Schema-Template:**

```jsonc theme={null}
{
  "name": "EntityName",
  "type": "object",
  "properties": {
    "field_name": {
      "type": "string",
      "description": "Field description"
    }
  },
  "required": ["field_name"]
}
```

**Feldtypen:** `string`, `number`, `integer`, `boolean`, `array`, `object`, `binary`
**String-Formate:** `date`, `date-time`, `time`, `email`, `uri`, `hostname`, `ipv4`, `ipv6`, `uuid`, `file`, `regex`, `richtext`
**Für Enums:** Füge `"enum": ["value1", "value2"]` und optional `"default": "value1"` hinzu
**Entitätsnamen:** Nur alphanumerisch (Muster: `/^[a-zA-Z0-9]+$/`)

Für die vollständige Dokumentation siehe [entities-create.md](https://docs.base44.com/developers/skills/base44-cli/references/entities-create.md).

### Funktionsverwaltung

| Aktion / Befehl                                | Beschreibung                                                                                             | Referenz                                                                                                   |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| Funktionen erstellen                           | Funktionen in `base44/functions` definieren                                                              | [functions-create.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-create.md) |
| `base44 functions deploy [names...] [--force]` | Lokale Funktionen zu Base44 deployen; optional bestimmte Funktionen anvisieren oder entfernte bereinigen | [functions-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-deploy.md) |
| `base44 functions delete <names...>`           | Eine oder mehrere deployte Funktionen aus Base44 löschen                                                 | [functions-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-delete.md) |
| `base44 functions list`                        | Alle auf Base44-Remote deployten Funktionen auflisten                                                    | [functions-list.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-list.md)     |
| `base44 functions pull [name]`                 | Deployte Funktionen von Base44 in lokale Dateien ziehen                                                  | [functions-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/functions-pull.md)     |

### Agenten-Verwaltung

Agenten sind konversationelle KI-Assistenten, die mit Nutzern interagieren, auf Entitäten deiner App zugreifen und Backend-Funktionen aufrufen können. Verwende diese Befehle, um Agenten-Konfigurationen zu verwalten.

| Aktion / Befehl      | Beschreibung                                 | Referenz                                                                                         |
| -------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| Agenten erstellen    | Agenten im Ordner `base44/agents` definieren | Siehe Agenten-Schema unten                                                                       |
| `base44 agents pull` | Remote-Agenten in lokale Dateien ziehen      | [agents-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-pull.md) |
| `base44 agents push` | Lokale Agenten zu Base44 pushen              | [agents-push.md](https://docs.base44.com/developers/skills/base44-cli/references/agents-push.md) |

**Hinweis:** Agent-Befehle führen eine vollständige Synchronisation durch — Push ersetzt alle Remote-Agenten durch die lokalen, Pull ersetzt alle lokalen Agenten durch die Remote-Agenten.

#### Agenten-Schema (Schnellreferenz)

**Dateiname:** `base44/agents/{agent_name}.jsonc` (z. B. `support_agent.jsonc`)

**Schema-Template:**

```jsonc theme={null}
{
  "name": "agent_name",
  "description": "Brief description of what this agent does",
  "instructions": "Detailed instructions for the agent's behavior",
  "tool_configs": [
    // Entity tool - gives agent access to entity operations
    { "entity_name": "tasks", "allowed_operations": ["read", "create", "update", "delete"] },
    // Backend function tool - gives agent access to a function
    { "function_name": "send_email", "description": "Send an email notification" }
  ],
  "whatsapp_greeting": "Hello! How can I help you today?"
}
```

**Benennungsregeln:**

* Agentennamen müssen dem Muster entsprechen: `/^[a-z0-9_]+$/` (kleingeschrieben, alphanumerisch mit Unterstrichen, 1–100 Zeichen)
* Gültig: `support_agent`, `order_bot`
* Ungültig: `Support-Agent`, `OrderBot`

**Erforderliche Felder:** `name`, `description`, `instructions`
**Optionale Felder:** `tool_configs` (Standardwert `[]`), `whatsapp_greeting`

**Tool-Config-Typen:**

* **Entity-Tools**: `entity_name` + `allowed_operations` (Array aus: `read`, `create`, `update`, `delete`)
* **Backend-Function-Tools**: `function_name` + `description`

### Connector-Verwaltung

Connectors verbinden deine App mit externen Diensten (Google Calendar, Slack, Stripe usw.). Die meisten Connectors nutzen OAuth, um Backend-Funktionen Access-Tokens für externe APIs bereitzustellen. Stripe ist die Ausnahme — es wird serverseitig automatisch bereitgestellt, ohne OAuth-Browser-Flow.

| Aktion / Befehl                    | Beschreibung                                            | Referenz                                                                                                                     |
| ---------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Connectors erstellen               | Connectors im Ordner `base44/connectors` definieren     | [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md)                 |
| `base44 connectors list-available` | Alle verfügbaren Integrationstypen von Base44 auflisten | [connectors-list-available.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-list-available.md) |
| `base44 connectors pull`           | Remote-Connectors in lokale Dateien ziehen              | [connectors-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-pull.md)                     |
| `base44 connectors push`           | Lokale Connectors zu Base44 pushen                      | [connectors-push.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-push.md)                     |

**Hinweis:** Connector-Befehle führen eine vollständige Synchronisation durch — Push ersetzt alle Remote-Connectors durch die lokalen (und löst OAuth für neue OAuth-Connectors aus), Pull ersetzt alle lokalen Connectors durch die Remote-Connectors.

#### Connector-Schema (Schnellreferenz)

**Dateiname:** `base44/connectors/{type}.jsonc` (z. B. `googlecalendar.jsonc`, `slack.jsonc`)

**Schema-Template:**

```jsonc theme={null}
{
  "type": "googlecalendar",
  "scopes": [
    "https://www.googleapis.com/auth/calendar.readonly",
    "https://www.googleapis.com/auth/calendar.events"
  ]
}
```

**Erforderliche Felder:** `type`
**Optionale Felder:** `scopes` (Standardwert `[]`)

**Verfügbare Connector-Typen:** Führe `npx base44 connectors list-available` aus, um alle unterstützten Integrationstypen zu sehen.

**Hinweis:** `stripe` ist auch ein gültiger Connector-Typ, wird aber nicht von `list-available` zurückgegeben. Behandle ihn als unterstützten Typ — er wird von Base44 automatisch ohne OAuth-Browser-Flow bereitgestellt. Siehe [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md) für Details.

Für die vollständige Dokumentation siehe [connectors-create.md](https://docs.base44.com/developers/skills/base44-cli/references/connectors-create.md).

### Auth-Konfiguration

Verwalte die Authentifizierungseinstellungen deiner App (z. B. Login mit Benutzername und Passwort). Die Auth-Konfiguration wird in `base44/auth/` gespeichert und über `auth push`/`auth pull` mit Base44 synchronisiert.

| Befehl                                                  | Beschreibung                                                                   | Referenz                                                                                                         |
| ------------------------------------------------------- | ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- |
| `base44 auth password-login <enable\|disable>`          | Authentifizierung per Benutzername und Passwort aktivieren oder deaktivieren   | [auth-password-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-password-login.md) |
| `base44 auth social-login <provider> <enable\|disable>` | Social-Login aktivieren oder deaktivieren (google, microsoft, facebook, apple) | [auth-social-login.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-social-login.md)     |
| `base44 auth sso <enable\|disable>`                     | SSO-Identitätsanbieter konfigurieren (google, microsoft, github, okta, custom) | [auth-sso.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-sso.md)                       |
| `base44 auth pull`                                      | Auth-Konfiguration von Base44 in lokale Dateien ziehen                         | [auth-pull.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-pull.md)                     |
| `base44 auth push`                                      | Lokale Auth-Konfiguration zu Base44 pushen                                     | [auth-push.md](https://docs.base44.com/developers/skills/base44-cli/references/auth-push.md)                     |

**Hinweis:** Die Auth-Konfiguration wird auch als Teil von `base44 deploy` deployt.

### Secrets-Verwaltung

Verwalte Projekt-Secrets (Umgebungsvariablen, die sicher in Base44 gespeichert sind). Diese Befehle sind in der `--help`-Ausgabe versteckt, aber voll funktionsfähig.

| Befehl                        | Beschreibung                                                | Referenz                                                                                               |
| ----------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 secrets list`         | Die Namen aller Secrets auflisten                           | [secrets-list.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-list.md)     |
| `base44 secrets set`          | Ein oder mehrere Secrets setzen (KEY=VALUE oder --env-file) | [secrets-set.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-set.md)       |
| `base44 secrets delete <key>` | Ein Secret nach Name löschen                                | [secrets-delete.md](https://docs.base44.com/developers/skills/base44-cli/references/secrets-delete.md) |

### Skript-Ausführung

Führe Einzelskripte gegen deine App mit dem vorauthentifizierten Base44-SDK aus. Nutze das für CRUD-Operationen auf Entitäten (`base44.entities.MyEntity.list/create/update/delete`), zum Aufrufen von Backend-Funktionen (`base44.functions.invoke("myFunction", args)`), zum Aufrufen von Agenten oder für den Zugriff auf jede andere vom SDK bereitgestellte Ressource — ohne eine vollständige Funktion zu deployen. Nützlich für Datenmigrationen, Massenoperationen, Debugging und skriptbasierte Workflows.

| Befehl        | Beschreibung                                                          | Referenz                                                                           |
| ------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `base44 exec` | Ein Skript (über stdin) mit vorauthentifiziertem Base44-SDK ausführen | [exec.md](https://docs.base44.com/developers/skills/base44-cli/references/exec.md) |

### Typ-Generierung

| Befehl                  | Beschreibung                                                                                 | Referenz                                                                                               |
| ----------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `base44 types generate` | TypeScript-Typen (`types.d.ts`) aus Entitäten, Funktionen, Agenten und Connectors generieren | [types-generate.md](https://docs.base44.com/developers/skills/base44-cli/references/types-generate.md) |

**Ausgabe:** `base44/.types/types.d.ts` — erweitert das Modul `@base44/sdk` mit typisierten Registries (`EntityTypeRegistry`, `FunctionNameRegistry`, `AgentNameRegistry`, `ConnectorTypeRegistry`).

**Keine Authentifizierung erforderlich.** Läuft komplett lokal. Aktualisiert `tsconfig.json` automatisch, um die generierten Typen einzuschließen.

### Site-Verwaltung

| Befehl               | Beschreibung                                     | Referenz                                                                                         |
| -------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| `base44 site deploy` | Gebaute Site-Dateien zum Base44-Hosting deployen | [site-deploy.md](https://docs.base44.com/developers/skills/base44-cli/references/site-deploy.md) |
| `base44 site open`   | Deployte Site im Browser öffnen                  | [site-open.md](https://docs.base44.com/developers/skills/base44-cli/references/site-open.md)     |

**Nur SPA**: Das Base44-Hosting unterstützt Single Page Applications mit einem einzigen `index.html`-Einstiegspunkt. Alle Routen werden aus `index.html` bedient (clientseitiges Routing).

## Schnellstart

1. Installiere die CLI in deinem Projekt:
   ```bash theme={null}
   npm install --save-dev base44
   ```

2. Authentifiziere dich bei Base44:
   ```bash theme={null}
   npx base44 login
   ```

3. Erstelle ein neues Projekt (gib IMMER Name und `--path`-Flag an):
   ```bash theme={null}
   npx base44 create my-app --path .
   ```

4. Führe lokale Entwicklung aus:
   ```bash theme={null}
   npx base44 dev
   ```

5. Baue und deploye alles:
   ```bash theme={null}
   npm run build
   npx base44 deploy -y
   ```

Oder deploye einzelne Ressourcen:

* `npx base44 entities push` — Nur Entitäten pushen
* `npx base44 functions deploy` — Nur Funktionen deployen
* `npx base44 functions delete <name>` — Eine deployte Funktion löschen
* `npx base44 functions list` — Alle deployten Funktionen auflisten
* `npx base44 functions pull` — Deployte Funktionen in lokale Dateien ziehen
* `npx base44 agents push` — Nur Agenten pushen
* `npx base44 connectors pull` — Connectors von Base44 ziehen
* `npx base44 connectors push` — Nur Connectors pushen
* `npx base44 auth pull` — Auth-Konfiguration von Base44 ziehen
* `npx base44 auth push` — Nur Auth-Konfiguration pushen
* `npx base44 site deploy -y` — Nur Site deployen

## Häufige Workflows

### Ein neues Projekt erstellen

**⚠️ VERPFLICHTEND: Bevor du `base44 create` ausführst, MUSST du [create.md](https://docs.base44.com/developers/skills/base44-cli/references/create.md) lesen, für:**

* **Template-Auswahl** — Wähle das richtige Template (`backend-and-client` vs `backend-only`)
* **Korrekter Workflow** — Verschiedene Templates erfordern verschiedene Einrichtungsschritte
* **Häufige Fallstricke** — Vermeide Ordner-Erstellungsfehler, die zu Fehlschlägen führen

Wenn du den Anweisungen in create.md nicht folgst, führt das zu kaputtem Projekt-Scaffolding.

### Ein bestehendes Projekt verknüpfen

```bash theme={null}
# If you have base44/config.jsonc but no .app.jsonc
npx base44 link --create --name my-app
```

### Lokale Entwicklung ausführen

```bash theme={null}
# Starts the Base44 backend locally
npx base44 dev
```

Wenn `base44 dev` auch dein Frontend ausführen soll, prüfe, dass in `base44/config.jsonc` `site.serveCommand` korrekt gesetzt ist (z. B. `"serveCommand": "npm run dev"`). Wenn dieses Feld vorhanden ist, führt `base44 dev` Backend und Frontend gemeinsam aus.

### Alle Änderungen deployen

```bash theme={null}
# Generate types (optional, for TypeScript projects)
npx base44 types generate

# Build your project first
npm run build

# Deploy everything (entities, functions, and site)
npx base44 deploy -y
```

### TypeScript-Typen generieren

```bash theme={null}
# Generate types from entities, functions, agents, and connectors
npx base44 types generate
```

Dies erstellt `base44/.types/types.d.ts` mit typisierten Registries für das `@base44/sdk`-Modul. Führe das nach Änderungen an Entitäten, Funktionen, Agenten oder Connectors aus, damit deine Typen aktuell bleiben. Keine Authentifizierung erforderlich.

### Einzelne Ressourcen deployen

```bash theme={null}
# Push only entities
npx base44 entities push

# Deploy only functions (all)
npx base44 functions deploy
# Deploy specific functions
npx base44 functions deploy my-function other-function
# Deploy and prune removed functions
npx base44 functions deploy --force

# Push only agents
npx base44 agents push

# Pull connectors from Base44
npx base44 connectors pull

# Push only connectors
npx base44 connectors push

# Deploy only site
npx base44 site deploy -y
```

### Das Dashboard öffnen

```bash theme={null}
# Open app dashboard in browser
npx base44 dashboard
```

## Authentifizierung

Die meisten Befehle erfordern Authentifizierung. Wenn du nicht eingeloggt bist, fordert die CLI dich automatisch dazu auf. Deine Sitzung wird lokal gespeichert und bleibt über CLI-Sitzungen hinweg bestehen.

## Fehlerbehebung

| Fehler                          | Lösung                                                                                                                     |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Not authenticated               | Führe zuerst `npx base44 login` aus                                                                                        |
| No entities found               | Stelle sicher, dass Entitäten im Verzeichnis `base44/entities/` existieren                                                 |
| Entity not recognized           | Prüfe, dass die Datei kebab-case-Benennung nutzt (z. B. `team-member.jsonc`, nicht `TeamMember.jsonc`)                     |
| No functions found              | Stelle sicher, dass Funktionen in `base44/functions/` mit `entry.ts` oder `entry.js` existieren                            |
| No agents found                 | Stelle sicher, dass Agenten im Verzeichnis `base44/agents/` mit gültigen `.jsonc`-Konfigurationen existieren               |
| Invalid agent name              | Agentennamen müssen kleingeschrieben, alphanumerisch mit Unterstrichen sein                                                |
| No connectors found             | Stelle sicher, dass Connectors im Verzeichnis `base44/connectors/` mit gültigen `.jsonc`-Konfigurationen existieren        |
| Invalid connector type          | Führe `npx base44 connectors list-available` aus, um gültige Typen zu sehen                                                |
| Duplicate connector type        | Jeder Connector-Typ darf pro Projekt nur einmal definiert werden                                                           |
| Connector authorization timeout | Führe `npx base44 connectors push` erneut aus und schließe den OAuth-Flow im Browser ab                                    |
| No site configuration found     | Prüfe, dass `site.outputDirectory` in der Projektkonfiguration konfiguriert ist                                            |
| Site deployment fails           | Stelle sicher, dass du zuerst `npm run build` ausgeführt hast und der Build erfolgreich war                                |
| Update available message        | Wenn du zum Update aufgefordert wirst, führe `npm install -g base44@latest` aus (oder nutze npx für lokale Installationen) |

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>