mythos-code 1.0.0 → 1.3.0

package/bin/mythos.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import readline from "node:readline";
-import { execSync } from "node:child_process";
+import { exec } from "node:child_process";
 
 const API = process.env.MYTHOS_API_URL || "https://rdxaqiacoitzeowehdts.supabase.co/functions/v1/v1-messages";
 const CFG = path.join(os.homedir(), ".mythos-code.json");
@@ -24,33 +24,112 @@ Du kannst Werkzeuge nutzen. Um ein Werkzeug aufzurufen, antworte mit GENAU EINEM
 <tool>{"name":"ls","path":"."}</tool>            -> Ordner auflisten
 Nach jedem Werkzeug bekommst du das Ergebnis. Arbeite Schritt für Schritt, bis die Aufgabe erledigt ist, dann antworte normal ohne <tool>. Sei präzise.`;
 
-async function login() {
-  console.log(C.c + "Hol dir einen kostenlosen API-Key im Mythos Dashboard (sk-ant-mythos-...)." + C.x);
-  const k = (await ask("API-Key: ")).trim();
+const SITE = process.env.MYTHOS_SITE_URL || "https://ai-mythos.lovable.app";
+const FN = process.env.MYTHOS_FN_URL || API.replace(/\/v1-messages$/, "");
+const authPost = async (body) => (await fetch(FN + "/cli-auth", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })).json();
+
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {});
+}
+
+async function loginWithKey() {
+  const k = (await ask("API-Key (sk-ant-mythos-...): ")).trim();
   if (!k.startsWith("sk-ant-mythos-")) { console.log(C.r + "Ungültiger Key." + C.x); process.exit(1); }
-  cfg.key = k; save(cfg); console.log(C.g + "✓ Gespeichert in " + CFG + C.x);
+  cfg.key = k; save(cfg); console.log(C.g + "✓ Angemeldet" + C.x);
 }
 
-async function call(messages) {
-  const r = await fetch(API, {
-    method: "POST",
-    headers: { "content-type": "application/json", "x-api-key": cfg.key, "anthropic-version": "2023-06-01" },
-    body: JSON.stringify({ model: cfg.model || "mythos-code", max_tokens: 8000, system: SYSTEM, messages }),
-  });
-  const j = await r.json().catch(() => ({}));
-  if (!r.ok) throw new Error(j?.error?.message || ("HTTP " + r.status));
-  return (j.content || []).map((p) => p.text || "").join("");
+// Anmeldung über die Website: Browser öffnet sich, dort auf "Authentifizieren" klicken.
+async function login() {
+  if (process.argv.includes("--key")) return loginWithKey();
+  let s;
+  try { s = await authPost({ action: "start", client: "cli" }); } catch { s = null; }
+  if (!s?.code) { console.log(C.r + "Anmeldung gerade nicht möglich – versuch es gleich nochmal." + C.x); process.exit(1); }
+  const url = SITE + "/cli-auth?code=" + s.code;
+  console.log(C.c + "\n  Anmeldung mit MythosAI" + C.x);
+  console.log("  Dein Browser öffnet sich. Klicke dort auf " + C.b + "Authentifizieren" + C.x + ".");
+  console.log(C.d + "  Code: " + s.code + "  ·  Falls sich nichts öffnet: " + url + C.x + "\n");
+  openBrowser(url);
+  const until = Date.now() + 15 * 60e3;
+  process.stdout.write(C.d + "  Warte auf Bestätigung…" + C.x);
+  while (Date.now() < until) {
+    await new Promise((r) => setTimeout(r, 2000));
+    let p; try { p = await authPost({ action: "poll", code: s.code, poll_secret: s.poll_secret }); } catch { continue; }
+    if (p.status === "ok") { cfg.key = p.api_key; cfg.name = p.name; save(cfg); clearLine(); console.log(C.g + "  ✓ Angemeldet als " + p.name + C.x + "\n"); return; }
+    if (p.status === "expired") break;
+  }
+  clearLine(); console.log(C.r + "  Anmeldung abgelaufen – starte nochmal mit: mythos login" + C.x); process.exit(1);
+}
+
+const fmt = (ms) => { const s = Math.floor(ms / 1000); return (s >= 60 ? Math.floor(s / 60) + "m " : "") + (s % 60) + "s"; };
+
+// Live-Timer: läuft während der ganzen Aufgabe (auch während Befehle laufen), pausiert nur für Rückfragen.
+let T0 = 0, tick = null;
+const clearLine = () => process.stdout.write("\r\x1b[K");
+const startTick = () => { if (tick) return; tick = setInterval(() => process.stdout.write("\r" + C.d + "⏳ Mythos arbeitet… " + fmt(Date.now() - T0) + C.x + "   "), 250); };
+const stopTick = () => { if (tick) { clearInterval(tick); tick = null; } clearLine(); };
+const say = (s) => { const was = !!tick; stopTick(); console.log(s); if (was) startTick(); };
+
+// Verlauf kürzen, damit lange Aufgaben nicht an zu großem Kontext scheitern. level 0 = mild, 2 = stark.
+const shorten = (s, max) => s.length <= max ? s : s.slice(0, Math.floor(max * 0.7)) + "\n…[gekürzt]…\n" + s.slice(s.length - Math.floor(max * 0.3));
+function compact(history, level) {
+  const keep = [6, 8, 4][level], recentMax = [20000, 3000, 1500][level], oldMax = [1500, 800, 400][level];
+  const cut = Math.max(0, history.length - keep);
+  const older = level === 0 ? history.slice(0, cut) : history.slice(0, Math.min(1, cut));
+  return older.map((m) => ({ role: m.role, content: shorten(m.content, oldMax) }))
+    .concat(history.slice(cut).map((m) => ({ role: m.role, content: shorten(m.content, recentMax) })));
+}
+
+async function once(messages) {
+  const ctl = new AbortController(); const to = setTimeout(() => ctl.abort(), 170000);
+  try {
+    const r = await fetch(API, {
+      method: "POST", signal: ctl.signal,
+      headers: { "content-type": "application/json", "x-api-key": cfg.key, "anthropic-version": "2023-06-01" },
+      body: JSON.stringify({ model: cfg.model || "mythos-code", max_tokens: 8000, system: SYSTEM, messages, stream: true }),
+    });
+    if (!r.ok) { const j = await r.json().catch(() => ({})); const e = new Error(j?.error?.message || ("HTTP " + r.status)); e.status = r.status; throw e; }
+    const reader = r.body.getReader(); const dec = new TextDecoder(); let buf = "", out = "";
+    while (true) {
+      const { done, value } = await reader.read(); if (done) break;
+      buf += dec.decode(value, { stream: true });
+      let i; while ((i = buf.indexOf("\n")) !== -1) {
+        const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+        if (!line.startsWith("data:")) continue;
+        let p; try { p = JSON.parse(line.slice(5)); } catch { continue; }
+        if (p.type === "error") { const e = new Error(p.error?.message || "Überlastet"); e.status = 529; throw e; }
+        if (p.delta?.text) out += p.delta.text;
+      }
+    }
+    if (!out.trim()) throw new Error("Leere Antwort");
+    return out;
+  } finally { clearTimeout(to); }
+}
+
+async function call(history) {
+  for (let a = 0; a < 6; a++) {
+    try { return await once(compact(history, Math.min(2, Math.floor(a / 2)))); }
+    catch (e) {
+      if (e.status === 401) throw new Error("Anmeldung ungültig – bitte neu anmelden: mythos login");
+      if (/Daily limit/i.test(e.message)) throw new Error("Tageslimit erreicht – mit Pro unbegrenzt.");
+      await new Promise((r) => setTimeout(r, Math.min(8000, 1500 * (a + 1))));
+    }
+  }
+  throw new Error("Mythos ist gerade nicht erreichbar – bitte gleich nochmal versuchen.");
 }
 
 async function runTool(t) {
   const show = t.name === "write" ? `write ${t.path} (${(t.content || "").length} Zeichen)` : `${t.name} ${t.cmd || t.path || ""}`;
-  console.log(C.y + "⚙  " + show + C.x);
+  say(C.y + "⚙  " + show + C.x);
   if ((t.name === "run" || t.name === "write") && !autoYes) {
+    stopTick();
     const a = (await ask(C.d + "   Erlauben? [j/N/a=immer] " + C.x)).trim().toLowerCase();
+    startTick();
     if (a === "a") autoYes = true; else if (a !== "j" && a !== "y") return "Vom Nutzer abgelehnt.";
   }
   try {
-    if (t.name === "run") return execSync(t.cmd, { encoding: "utf8", stdio: "pipe", timeout: 120000, maxBuffer: 1e7 }).slice(-8000) || "(keine Ausgabe)";
+    if (t.name === "run") return await new Promise((res) => exec(t.cmd, { encoding: "utf8", timeout: 180000, maxBuffer: 1e7 },
+      (err, so, se) => res(((so || "") + (se || "") + (err ? "\nExit: " + (err.code ?? err.message) : "")).slice(-8000) || "(keine Ausgabe)")));
     if (t.name === "read") return fs.readFileSync(t.path, "utf8").slice(0, 20000);
     if (t.name === "write") { fs.mkdirSync(path.dirname(path.resolve(t.path)), { recursive: true }); fs.writeFileSync(t.path, t.content ?? ""); return "OK geschrieben: " + t.path; }
     if (t.name === "ls") return fs.readdirSync(t.path || ".", { withFileTypes: true }).map((e) => (e.isDirectory() ? "📁 " : "   ") + e.name).join("\n");
@@ -59,14 +138,19 @@ async function runTool(t) {
 }
 
 async function turn(history, input) {
+  T0 = Date.now(); startTick();
+  try { await turnInner(history, input); }
+  catch (e) { say(C.r + "⚠ " + e.message + C.x); }
+  finally { stopTick(); console.log(C.g + "✓ Mythos hat " + fmt(Date.now() - T0) + " gearbeitet" + C.x + "\n"); }
+}
+async function turnInner(history, input) {
   history.push({ role: "user", content: input });
-  for (let i = 0; i < 25; i++) {
-    process.stdout.write(C.d + "… denkt" + C.x + "\r");
+  for (let i = 0; i < 40; i++) {
     const out = await call(history);
     history.push({ role: "assistant", content: out });
     const m = out.match(/<tool>([\s\S]*?)<\/tool>/);
     const text = out.replace(/<tool>[\s\S]*?<\/tool>/g, "").trim();
-    if (text) console.log(C.b + "Mythos: " + C.x + text + "\n");
+    if (text) say(C.b + "Mythos: " + C.x + text + "\n");
     if (!m) return;
     let t; try { t = JSON.parse(m[1]); } catch { history.push({ role: "user", content: "Tool-JSON ungültig." }); continue; }
     const res = await runTool(t);
@@ -75,7 +159,7 @@ async function turn(history, input) {
 }
 
 async function main() {
-  const args = process.argv.slice(2).filter((a) => a !== "--yes");
+  const args = process.argv.slice(2).filter((a) => a !== "--yes" && a !== "--key");
   if (args[0] === "login" || !cfg.key) await login();
   if (args[0] === "login") process.exit(0);
   if (args[0] === "logout") { save({}); console.log("Abgemeldet."); process.exit(0); }
@@ -87,7 +171,7 @@ async function main() {
     if (!q) continue;
     if (q === "/exit") break;
     if (q === "/clear") { history.length = 0; console.log("Verlauf geleert."); continue; }
-    try { await turn(history, q); } catch (e) { console.log(C.r + "Fehler: " + e.message + C.x); }
+    await turn(history, q);
   }
   rl.close();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythos-code",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Mythos Code – KI-Coding-Agent im Terminal (by Mythoscraft)",
   "bin": {
     "mythos": "bin/mythos.js",