einzly-mcp 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# einzly MCP
+
+Steuere deine [einzly](https://www.einzly.ch)-Buchhaltung über Claude, Cursor und andere
+AI-Agenten — Rechnungen, Offerten, Ausgaben, Aufträge und Auswertungen per Sprache.
+Du nutzt deine eigenen Claude-/AI-Tokens; einzly stellt nur die sichere Datenschnittstelle.
+
+## Einrichtung
+
+1. In einzly: **Einstellungen → Entwickler → API-Schlüssel erstellen** (Pro-Abo).
+2. MCP registrieren:
+
+   **Claude Code / Claude Desktop:**
+   ```
+   claude mcp add einzly --env EINZLY_API_KEY=ek_live_… -- npx -y einzly-mcp
+   ```
+
+   **Andere MCP-Clients (z. B. Cursor)** — in der MCP-Konfiguration:
+   ```json
+   {
+     "mcpServers": {
+       "einzly": {
+         "command": "npx",
+         "args": ["-y", "einzly-mcp"],
+         "env": { "EINZLY_API_KEY": "ek_live_…" }
+       }
+     }
+   }
+   ```
+3. Client neu starten.
+
+## Was du sagen kannst
+
+- „Zeig mir meine offenen Rechnungen / meinen besten Kunden / Ausgaben mit MWST dieses Jahr."
+- „Erstell eine Rechnung für [Kunde] über 2 Tage à 1'200."
+- „Mach eine 30%-Anzahlung für Auftrag A-2026-005." → „Erstell die Schlussrechnung dazu."
+- „Versende Rechnung R-2026-012." (kommt mit Bestätigungs-Rückfrage)
+
+## Sicherheit
+
+- **Versand** (Rechnung/Offerte) erfordert immer eine **ausdrückliche Bestätigung** (`confirm=true`).
+- Der Schlüssel hat vollen Zugriff auf dein Konto — wie ein Passwort behandeln, jederzeit im
+  Entwickler-Tab widerrufbar.
+
+## Eigener Code / eigene Tools
+
+Der Schlüssel funktioniert auch direkt gegen die HTTP-API:
+
+```
+curl -X POST https://www.einzly.ch/api/agent \
+  -H "Authorization: Bearer ek_live_…" \
+  -H "Content-Type: application/json" \
+  -d '{"tool":"get_dashboard_summary","input":{}}'
+```
+
+## Umgebungsvariablen
+
+- `EINZLY_API_KEY` — dein API-Schlüssel (empfohlen).
+- `EINZLY_BASE_URL` — optional, Default `https://www.einzly.ch`.

package/einzly-mcp.mjs

@@ -0,0 +1,435 @@
+#!/usr/bin/env node
+// einzly MCP-Server (read-only MVP).
+// Teilt die Auth mit dem CLI: liest ~/.einzly/session.json (vorher `einzly login`).
+// Exponiert Lese-Tools für Claude/Agents. WICHTIG: bei stdio nur auf stderr loggen,
+// stdout gehört dem MCP-Protokoll.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SESSION_FILE = join(homedir(), ".einzly", "session.json");
+
+function publicConfig() {
+  let url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  let anon = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+  if ((!url || !anon) && existsSync(join(__dirname, "..", ".env.local"))) {
+    for (const line of readFileSync(join(__dirname, "..", ".env.local"), "utf8").split("\n")) {
+      const m = line.match(/^([A-Z_]+)=(.*)$/);
+      if (!m) continue;
+      const v = m[2].replace(/^["']|["']$/g, "");
+      if (m[1] === "NEXT_PUBLIC_SUPABASE_URL") url = url || v;
+      if (m[1] === "NEXT_PUBLIC_SUPABASE_ANON_KEY") anon = anon || v;
+    }
+  }
+  return { url, anon };
+}
+
+// Auth-Token holen: bevorzugt EINZLY_API_KEY (Entwickler-Tab in einzly), sonst CLI-Login-Session.
+// Gibt { token } zurück — ALLE Tools laufen über /api/agent bzw. /api/send-* (kein direkter
+// Supabase-Zugriff mehr), damit der API-Key (kein Supabase-JWT) voll funktioniert.
+async function authed() {
+  const apiKey = process.env.EINZLY_API_KEY;
+  if (apiKey && apiKey.trim()) return { token: apiKey.trim() };
+
+  if (!existsSync(SESSION_FILE)) {
+    throw new Error("Kein Zugang. Setze EINZLY_API_KEY (Einstellungen → Entwickler in einzly) oder logge dich ein: `node cli/einzly.mjs login`.");
+  }
+  const sess = JSON.parse(readFileSync(SESSION_FILE, "utf8"));
+  const { url, anon } = publicConfig();
+  if (!url || !anon) throw new Error("Supabase-Konfiguration fehlt (NEXT_PUBLIC_SUPABASE_URL/ANON_KEY).");
+  // Nur der Login-Fallback braucht Supabase — im Key-Modus (EINZLY_API_KEY) wird das nie geladen.
+  const { createClient } = await import("@supabase/supabase-js");
+  const supabase = createClient(url, anon, { auth: { persistSession: false, autoRefreshToken: false } });
+  const { data, error } = await supabase.auth.setSession(sess);
+  if (error || !data.user) throw new Error("Session abgelaufen. Bitte neu einloggen: `node cli/einzly.mjs login`.");
+  // erneuerte Session zurückschreiben (Token-Rotation überlebt)
+  if (data.session) {
+    try {
+      writeFileSync(SESSION_FILE, JSON.stringify({ access_token: data.session.access_token, refresh_token: data.session.refresh_token }), { mode: 0o600 });
+    } catch { /* nicht kritisch */ }
+  }
+  return { token: data.session.access_token };
+}
+
+// Lese-Tools laufen über den Agent-Endpoint (eine Wahrheit, funktioniert mit Key ODER Login).
+async function query(tool, input) {
+  const { token } = await authed();
+  return callAgent(token, tool, input || {});
+}
+const yearToRange = (year) => (year ? { von: `${year}-01-01`, bis: `${year}-12-31` } : {});
+
+// Schreib-/Rechen-Aktionen laufen über den authentifizierten einzly-Agent-Endpoint
+// (reused die App-Tool-Logik = eine Wahrheit, kein Doppel-Code).
+// Default = Produktion. Für lokale Entwicklung: EINZLY_BASE_URL=http://localhost:3000 setzen.
+const BASE_URL = process.env.EINZLY_BASE_URL || "https://www.einzly.ch";
+async function callAgent(token, tool, input) {
+  const res = await fetch(`${BASE_URL}/api/agent`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ tool, input }),
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(json.error || `Agent-Endpoint HTTP ${res.status}`);
+  return json.result;
+}
+
+async function callSendInvoice(token, payload) {
+  const res = await fetch(`${BASE_URL}/api/send-invoice`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(json.error || `send-invoice HTTP ${res.status}`);
+  return json;
+}
+
+const ok = (data) => ({ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] });
+const fail = (e) => ({ content: [{ type: "text", text: `Fehler: ${e.message || e}` }], isError: true });
+const yearRange = (year) => [`${year}-01-01`, `${year}-12-31`];
+
+// Rechnungs-Total — MUSS synchron bleiben mit src/lib/format.ts (positionTotal/calcSubtotal)
+// + getTotal in src/app/(app)/rechnungen/page.tsx. Siehe memory einzly-invoice-calc-paths.
+function positionTotal(menge, preis, rabattProzent, inklusivMenge) {
+  const eff = Math.max(0, (menge || 0) - (inklusivMenge || 0));
+  const brutto = eff * (preis || 0);
+  if (!rabattProzent || rabattProzent <= 0) return brutto;
+  return brutto * (1 - rabattProzent / 100);
+}
+function calcSubtotal(positionen) {
+  return (positionen || []).reduce((sum, pos, i) => {
+    if (pos.position_type === "prozentualer_rabatt") {
+      const prozent = pos.prozent_wert || 0;
+      const basis = positionen.slice(0, i).reduce((s, p) =>
+        p.position_type === "prozentualer_rabatt" ? s : s + positionTotal(p.menge, p.preis, p.rabatt_prozent, p.inklusiv_menge), 0);
+      return sum - Math.round(basis * prozent / 100 * 100) / 100;
+    }
+    return sum + positionTotal(pos.menge, pos.preis, pos.rabatt_prozent, pos.inklusiv_menge);
+  }, 0);
+}
+function invoiceTotal(r, mwstStatus) {
+  if (r.waehrung && r.waehrung !== "CHF" && r.betrag_chf != null) return r.betrag_chf;
+  const sub = calcSubtotal(r.rechnung_positionen || []);
+  const rate = mwstStatus === "keine" ? 0 : (r.mwst_typ && r.mwst_typ !== "normal") ? 0 : 8.1;
+  return Math.round(sub * (1 + rate / 100) * 100) / 100;
+}
+// Offerten speichern Positionen als JSONB-Spalte `positionen`.
+function quoteTotal(o, mwstStatus) {
+  const sub = calcSubtotal(o.positionen || []);
+  const rate = mwstStatus === "keine" ? 0 : (o.mwst_typ && o.mwst_typ !== "normal") ? 0 : 8.1;
+  return Math.round(sub * (1 + rate / 100) * 100) / 100;
+}
+
+const server = new McpServer({ name: "einzly", version: "0.1.0" });
+
+server.tool(
+  "list_expenses",
+  "Listet die Ausgaben (Belastungen) des eingeloggten einzly-Nutzers. Optional nach Jahr gefiltert.",
+  { year: z.string().optional(), limit: z.number().optional() },
+  async ({ year, limit }) => {
+    try { return ok(await query("query_ausgaben", { ...yearToRange(year), limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "list_invoices",
+  "Listet die Rechnungen des Nutzers inkl. Betrag (CHF, inkl. MWST). Optional nach Status (entwurf, versendet, bezahlt, ueberfaellig). Zum offenen Gesamtbetrag: Status 'versendet'/'ueberfaellig' summieren.",
+  { status: z.string().optional(), limit: z.number().optional() },
+  async ({ status, limit }) => {
+    try { return ok(await query("query_rechnungen", { status, limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "list_income",
+  "Listet die Einnahmen des Nutzers. Optional nach Jahr gefiltert.",
+  { year: z.string().optional(), limit: z.number().optional() },
+  async ({ year, limit }) => {
+    try { return ok(await query("query_einnahmen", { ...yearToRange(year), limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "list_clients",
+  "Listet die Kunden des Nutzers (Firma, Kontakt, E-Mail, Telefon, Ort). Optionale Suche nach Name.",
+  { search: z.string().optional(), limit: z.number().optional() },
+  async ({ search, limit }) => {
+    try { return ok(await query("query_kunden", { name: search, limit: limit ?? 100 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "client_revenue",
+  "Kundenliste mit Umsätzen: summiert die Rechnungs-Totals (inkl. MWST) pro Kunde, absteigend sortiert (oberster = bester Kunde). Zählt ausgestellte Rechnungen (ohne Entwürfe). Optional nach Jahr.",
+  { year: z.string().optional(), limit: z.number().optional() },
+  async ({ year, limit }) => {
+    try { return ok(await query("query_kunden_umsatz", { ...yearToRange(year), limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+// ---------- Schreib-Tools ----------
+
+server.tool(
+  "create_client",
+  "Legt einen neuen Kunden an. firma_name = Firmenname ODER Vor-/Nachname.",
+  {
+    firma_name: z.string(),
+    kontakt_person: z.string().optional(),
+    email: z.string().optional(),
+    telefon: z.string().optional(),
+    adresse_strasse: z.string().optional(),
+    adresse_nr: z.string().optional(),
+    adresse_plz: z.string().optional(),
+    adresse_ort: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_kunde", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_invoice_draft",
+  "Erstellt eine EIGENSTÄNDIGE Rechnung als ENTWURF (ohne Auftragsbezug, wird NICHT versendet). Kunde muss bereits existieren. ACHTUNG: Hat der Kunde einen offenen Auftrag, lieber create_invoice_from_order / create_partial_invoice / create_final_invoice nehmen — sonst Doppelverrechnung. Bei offenem Auftrag liefert das Tool eine Warnung statt zu erstellen; nur mit trotzdem_neu=true bewusst überschreiben.",
+  {
+    kunde: z.string(),
+    positionen: z.array(z.object({
+      beschreibung: z.string(),
+      preis: z.number(),
+      menge: z.number().optional(),
+      detail: z.string().optional(),
+    })),
+    zahlungsziel_tage: z.number().optional(),
+    notiz: z.string().optional(),
+    trotzdem_neu: z.boolean().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_rechnung", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_invoice_from_order",
+  "Erstellt eine VOLLRECHNUNG (Entwurf) aus einem bestehenden Auftrag: übernimmt die Positionen, verknüpft Auftrag+Offerte und schliesst den Auftrag ab (verhindert Doppelverrechnung). Wenn bereits Teilrechnungen existieren → stattdessen create_final_invoice.",
+  {
+    auftrag: z.string().describe("Auftragsnummer oder eindeutiger Titel"),
+    zahlungsziel_tage: z.number().optional(),
+    notiz: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_rechnung_aus_auftrag", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_partial_invoice",
+  "Erstellt eine TEILRECHNUNG/Anzahlung (Entwurf) zu einem Auftrag. Der Auftrag bleibt offen. Betrag als prozent (Anteil am Auftragstotal) ODER betrag (Bruttobetrag CHF inkl. MWST). Beispiel '30% Anzahlung' → prozent=30.",
+  {
+    auftrag: z.string().describe("Auftragsnummer oder eindeutiger Titel"),
+    prozent: z.number().optional().describe("Prozent des Auftrags-Nettototals, z.B. 30"),
+    betrag: z.number().optional().describe("Bruttobetrag dieser Teilrechnung in CHF (inkl. MWST)"),
+    zahlungsziel_tage: z.number().optional(),
+    notiz: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_teilrechnung", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_final_invoice",
+  "Erstellt die SCHLUSSRECHNUNG (Entwurf) zu einem Auftrag: volle Positionen MINUS bereits gestellte Teilrechnungen (automatische Abzugs-Positionen) und schliesst den Auftrag ab.",
+  {
+    auftrag: z.string().describe("Auftragsnummer oder eindeutiger Titel"),
+    zahlungsziel_tage: z.number().optional(),
+    notiz: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_schlussrechnung", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_recurring_invoice",
+  "Richtet eine wiederkehrende Rechnung ein (z.B. Retainer/Abo). Erstellt automatisch Entwürfe im Intervall.",
+  {
+    kunde: z.string(),
+    positionen: z.array(z.object({ beschreibung: z.string(), preis: z.number(), menge: z.number().optional() })),
+    intervall: z.string().optional(),
+    zahlungsziel: z.number().optional(),
+    notiz: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_wiederkehrende_rechnung", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_income",
+  "Verbucht eine direkte Einnahme (ohne Rechnung) — z.B. bar, TWINT, PayPal.",
+  {
+    beschreibung: z.string(),
+    betrag: z.number(),
+    zahlungsart: z.string().optional(),
+    buchungstext: z.string().optional(),
+    datum: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_einnahme", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_expense",
+  "Bucht eine einmalige Ausgabe. Hinweis: Der Beleg muss separat in einzly hochgeladen werden (eine Bankzeile/Buchung ist kein gültiger Leistungsbeleg).",
+  {
+    lieferant: z.string(),
+    betrag: z.number(),
+    kategorie: z.string().optional(),
+    datum: z.string().optional(),
+    bezahlt_mit: z.string().optional(),
+    buchungstext: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_ausgabe", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "send_invoice",
+  "Versendet eine Rechnung per E-Mail an den Kunden. SICHERHEIT: Ohne confirm=true wird NUR eine Vorschau zurückgegeben (KEIN Versand). Zeige dem Nutzer Empfänger + Betrag, hole seine ausdrückliche Zustimmung, und rufe DANN erneut mit confirm=true auf. Setze confirm=true NIEMALS ohne explizite Bestätigung des Nutzers. (Pro-Abo erforderlich.)",
+  {
+    rechnung_nr: z.string(),
+    confirm: z.boolean().optional(),
+    email: z.string().optional(),
+    nachricht: z.string().optional(),
+  },
+  async ({ rechnung_nr, confirm, email, nachricht }) => {
+    try {
+      const { token } = await authed();
+      const r = await callAgent(token, "resolve_versand", { typ: "rechnung", nummer: rechnung_nr });
+      if (r?.error) return fail(new Error(r.error));
+      const recipient = (email || r.empfaenger || "").trim();
+      const betrag = `${r.waehrung || "CHF"} ${Number(r.betrag).toFixed(2)}`;
+      if (!recipient) {
+        return ok({ versand: false, grund: "Keine Empfänger-E-Mail hinterlegt. Bitte email angeben.", rechnung: rechnung_nr, kunde: r.kunde });
+      }
+      if (confirm !== true) {
+        return ok({
+          vorschau: true,
+          versand: false,
+          rechnung: rechnung_nr,
+          kunde: r.kunde,
+          empfaenger: recipient,
+          betrag,
+          status: r.status,
+          hinweis: "Versand NICHT ausgeführt. Bestätige Empfänger und Betrag mit dem Nutzer, dann send_invoice erneut mit confirm=true aufrufen.",
+        });
+      }
+      await callSendInvoice(token, { rechnung_id: r.id, email: recipient, nachricht: nachricht || undefined });
+      return ok({ versand: true, rechnung: rechnung_nr, empfaenger: recipient, betrag });
+    } catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "list_quotes",
+  "Listet Offerten inkl. Betrag (CHF). Optional nach Status (entwurf, versendet, angenommen, abgelehnt, abgelaufen).",
+  { status: z.string().optional(), limit: z.number().optional() },
+  async ({ status, limit }) => {
+    try { return ok(await query("query_offerten", { status, limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "create_quote_draft",
+  "Erstellt eine Offerte als ENTWURF. Kunde muss bereits existieren (sonst zuerst create_client).",
+  {
+    kunde: z.string(),
+    positionen: z.array(z.object({ beschreibung: z.string(), preis: z.number(), menge: z.number().optional(), detail: z.string().optional() })),
+    gueltig_tage: z.number().optional(),
+    notiz: z.string().optional(),
+  },
+  async (args) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "create_offerte", args)); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "send_quote",
+  "Versendet eine Offerte per E-Mail. SICHERHEIT: ohne confirm=true nur Vorschau (kein Versand). Empfänger + Betrag dem Nutzer zeigen, ausdrückliche Zustimmung holen, DANN confirm=true. (Pro-Abo erforderlich.)",
+  {
+    offerten_nr: z.string(),
+    confirm: z.boolean().optional(),
+    email: z.string().optional(),
+    nachricht: z.string().optional(),
+  },
+  async ({ offerten_nr, confirm, email, nachricht }) => {
+    try {
+      const { token } = await authed();
+      const o = await callAgent(token, "resolve_versand", { typ: "offerte", nummer: offerten_nr });
+      if (o?.error) return fail(new Error(o.error));
+      const recipient = (email || o.empfaenger || "").trim();
+      const betrag = `${o.waehrung || "CHF"} ${Number(o.betrag).toFixed(2)}`;
+      if (!recipient) {
+        return ok({ versand: false, grund: "Keine Empfänger-E-Mail hinterlegt. Bitte email angeben.", offerte: offerten_nr, kunde: o.kunde });
+      }
+      if (confirm !== true) {
+        return ok({ vorschau: true, versand: false, offerte: offerten_nr, kunde: o.kunde, empfaenger: recipient, betrag, status: o.status,
+          hinweis: "Versand NICHT ausgeführt. Empfänger und Betrag mit dem Nutzer bestätigen, dann send_quote erneut mit confirm=true aufrufen." });
+      }
+      const res = await fetch(`${BASE_URL}/api/send-offerte`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ offerte_id: o.id, email: recipient, nachricht: nachricht || undefined }),
+      });
+      const j = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(j.error || `send-offerte HTTP ${res.status}`);
+      return ok({ versand: true, offerte: offerten_nr, empfaenger: recipient, betrag });
+    } catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "list_orders",
+  "Listet Aufträge (auftrags_nr, Titel, Status, Start-/Abschlussdatum, Kunde).",
+  { limit: z.number().optional() },
+  async ({ limit }) => {
+    try { const { token } = await authed(); return ok(await callAgent(token, "query_auftraege", { limit: limit ?? 50 })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+server.tool(
+  "dashboard_summary",
+  "Liefert eine Finanz-Zusammenfassung (Total Einnahmen, Total Ausgaben, Saldo) für ein Jahr (Default: laufendes Jahr).",
+  { year: z.string().optional() },
+  async ({ year }) => {
+    try { return ok(await query("get_dashboard_summary", { jahr: year ? Number(year) : new Date().getFullYear() })); }
+    catch (e) { return fail(e); }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("einzly MCP-Server bereit (read-only).");

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "einzly-mcp",
+  "version": "0.1.0",
+  "description": "MCP-Server für einzly — steuere deine Schweizer Buchhaltung (Rechnungen, Offerten, Ausgaben, Aufträge, Auswertungen) über Claude, Cursor und andere AI-Agenten.",
+  "type": "module",
+  "bin": {
+    "einzly-mcp": "einzly-mcp.mjs"
+  },
+  "files": [
+    "einzly-mcp.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "homepage": "https://www.einzly.ch",
+  "keywords": [
+    "einzly",
+    "mcp",
+    "model-context-protocol",
+    "buchhaltung",
+    "claude"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "optionalDependencies": {
+    "@supabase/supabase-js": "^2.97.0"
+  }
+}