blun-king-cli 5.4.0 → 6.0.0

package/runtime.js

@@ -1,570 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const {
-  getIdentity,
-  findIdentityInText,
-  recommendIdentity,
-  listIdentities
-} = require("./identities");
-const { hasApproxWord, hasApproxPhrase } = require("./fuzzy-match");
-
-const REGISTRY = {
-  active: {
-    core: "v500",
-    roles: {
-      default: "v3",
-      dev: "v3",
-      operator: "v3",
-      critic: "v3",
-      support: "v3",
-      web_ui: "v3",
-      website_builder: "v3",
-      artifact: "v3",
-      research: "v3",
-      installer: "v3"
-    }
-  }
-};
-
-function normalize(text) {
-  return String(text || "")
-    .normalize("NFD")
-    .replace(/[\u0300-\u036f]/g, "")
-    .toLowerCase()
-    .replace(/ß/g, "ss")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function hasAny(text, phrases) {
-  return phrases.some((phrase) => text.includes(phrase));
-}
-
-function scoreExact(text, phrases, weight = 1) {
-  return phrases.reduce((score, phrase) => score + (text.includes(phrase) ? weight : 0), 0);
-}
-
-function scoreApproxWords(text, words, weight = 1) {
-  return words.reduce((score, word) => score + (hasApproxWord(text, [word]) ? weight : 0), 0);
-}
-
-function scoreApproxPhrases(text, phrases, weight = 1) {
-  return phrases.reduce((score, phrase) => score + (hasApproxPhrase(text, phrase) ? weight : 0), 0);
-}
-
-function clampConfidence(score) {
-  return Math.max(0, Math.min(1, score / 8));
-}
-
-function hasResolvableUrl(text) {
-  return /https?:\/\/\S+/i.test(String(text || "")) ||
-    /\b(?:www\.)?[a-z0-9.-]+\.[a-z]{2,}(?:\/\S*)?\b/i.test(String(text || ""));
-}
-
-function detectIntent(raw, session) {
-  const text = normalize(raw);
-  const activeTask = session?.activeTask || null;
-
-  const continuationWords = [
-    "mach weiter",
-    "weiter",
-    "mach fertig",
-    "arbeite autonom",
-    "zieh durch",
-    "weiter machen",
-    "go on",
-    "continue",
-    "finish it",
-    "mach einfach",
-    "und jetzt",
-    "weitermachen",
-    "findest du auch selbst",
-    "kannst du auch selbst",
-    "such selbst",
-    "such dir selbst"
-  ];
-  const analysisTerms = [
-    "analysier",
-    "analyse",
-    "anschauen",
-    "anschau",
-    "review",
-    "bewerte",
-    "bewerten",
-    "audit",
-    "check",
-    "kritisiere",
-    "verbessern",
-    "umbauen"
-  ];
-  const websiteTerms = [
-    "landingpage",
-    "landing page",
-    "website",
-    "webseite",
-    "homepage",
-    "onepager",
-    "hero",
-    "cta",
-    "index.html",
-    "style.css",
-    "nicrazy.com",
-    "url"
-  ];
-  const screenshotTerms = [
-    "screenshot",
-    "bild",
-    "foto",
-    "aufnahme",
-    "screen",
-    "abbild"
-  ];
-  const buildTerms = [
-    "baue",
-    "bau",
-    "erstelle",
-    "erstell",
-    "mach",
-    "machen",
-    "ueberarbeite",
-    "uberarbeite",
-    "redesign"
-  ];
-  const systemTerms = [
-    "ki",
-    "ai",
-    "system",
-    "modell",
-    "agent",
-    "prompt",
-    "routing",
-    "antwort",
-    "antworten",
-    "identitat",
-    "identitaten",
-    "persona",
-    "speicher",
-    "daten"
-  ];
-  const qualityTerms = [
-    "falsch",
-    "schlecht",
-    "unsauber",
-    "kaputt",
-    "verliert",
-    "halluziniert",
-    "inkonsistent",
-    "problem"
-  ];
-  const fileTerms = [
-    "als datei",
-    "als txt",
-    "als json",
-    "als zip",
-    "zum download",
-    "download",
-    "datei",
-    "file",
-    "artefakt",
-    "artefakte"
-  ];
-  const debugTerms = [
-    "error",
-    "typeerror",
-    "referenceerror",
-    "syntaxerror",
-    "fehler",
-    "bug",
-    "geht nicht",
-    "funktioniert nicht",
-    "timeout"
-  ];
-  const operatorTerms = [
-    "prioritat",
-    "priorisieren",
-    "task",
-    "operator",
-    "blocker",
-    "naechste schritte",
-    "nachste schritte",
-    "plan"
-  ];
-  const codingTerms = [
-    "api",
-    "route",
-    "backend",
-    "frontend",
-    "node",
-    "express",
-    "javascript",
-    "html",
-    "css",
-    "sql",
-    "python",
-    "code"
-  ];
-  const installTerms = [
-    "installier",
-    "installiere",
-    "install",
-    "installen",
-    "plugin",
-    "plugins",
-    "skill",
-    "skills",
-    "telegram bot",
-    "playwright",
-    "npm paket",
-    "paket installieren",
-    "github installieren",
-    "extension"
-  ];
-
-  const wantsFollowup = hasAny(text, continuationWords) || hasApproxWord(text, ["weiter", "weitermachen", "selbst", "continue", "findest"]);
-  const wantsAnalysis = hasAny(text, analysisTerms) || hasApproxWord(text, ["analysier", "analyse", "review"]);
-  const wantsWebsite = hasAny(text, websiteTerms) || hasApproxWord(text, ["website", "webseite", "landingpage", "homepage"]);
-  const wantsBuild = hasAny(text, buildTerms) || hasApproxWord(text, ["baue", "erstelle", "redesign"]);
-  const wantsSystem = hasAny(text, systemTerms);
-  const wantsQuality = hasAny(text, qualityTerms);
-  const wantsFiles = hasAny(text, fileTerms);
-  const wantsScreenshot = hasAny(text, screenshotTerms) || hasApproxWord(text, ["screenshot", "screen", "bild"]);
-  const wantsDebug = hasAny(text, debugTerms);
-  const wantsOperator = hasAny(text, operatorTerms);
-  const wantsCoding = hasAny(text, codingTerms);
-
-  const screenshotStorageFollowup =
-    activeTask?.type === "browser_capture" &&
-    wantsScreenshot &&
-    !hasResolvableUrl(raw) &&
-    /(ordner|datei|file|gespeichert|download|liegt|finde|fehlt|nicht im ordner|nicht da|wo ist)/i.test(text);
-
-  const scores = {
-    installation:
-      scoreExact(text, installTerms, 1) +
-      scoreApproxWords(text, ["installier", "installieren", "telegram", "telegramm", "plugin", "skill", "playwright"], 1.5) +
-      scoreApproxPhrases(text, ["telegram bot", "playwright"], 2),
-    browser_capture:
-      (wantsWebsite ? 2 : scoreApproxWords(text, ["website", "webseite"], 1.5)) +
-      (wantsScreenshot ? 3 : scoreApproxWords(text, ["screenshot", "screen"], 1.5)),
-    website_builder:
-      (wantsWebsite ? 2 : scoreApproxWords(text, ["website", "webseite", "landingpage", "homepage"], 1.5)) +
-      (wantsBuild ? 2 : scoreApproxWords(text, ["baue", "erstelle", "redesign"], 1.5)),
-    website_analysis:
-      (wantsWebsite ? 2 : scoreApproxWords(text, ["website", "webseite"], 1.5)) +
-      (wantsAnalysis ? 2 : 0),
-    system_analysis:
-      (wantsSystem ? 1.5 : 0) +
-      (wantsQuality ? 1 : 0) +
-      (wantsAnalysis ? 2 : 0),
-    debugging: wantsDebug ? 3 : 0,
-    file_generation: wantsFiles ? 2 : 0,
-    operator: wantsOperator ? 2 : 0,
-    coding: wantsCoding ? 2 : 0,
-    chat: 0
-  };
-
-  if (activeTask && wantsFollowup && !wantsAnalysis && !wantsDebug) {
-    return { kind: "followup", activeTask, scores, confidence: 1 };
-  }
-
-  if (screenshotStorageFollowup) {
-    return { kind: "followup", activeTask, scores, confidence: 1 };
-  }
-
-  if (/^(hi|hey|hallo|moin|servus|yo|na|guten morgen|guten abend)\b/.test(text) && text.split(" ").length <= 5) {
-    return { kind: "chat", scores, confidence: 1 };
-  }
-
-  const ranked = Object.entries(scores).sort((a, b) => b[1] - a[1]);
-  const [topKind, topScore] = ranked[0];
-  const confidence = clampConfidence(topScore);
-
-  if (topScore < 2) {
-    return { kind: "chat", scores, confidence };
-  }
-
-  switch (topKind) {
-    case "installation":
-      return { kind: "install", scores, confidence };
-    case "browser_capture":
-      return { kind: "browser_capture", scores, confidence };
-    case "website_builder":
-      return { kind: "build", domain: "website", scores, confidence };
-    case "website_analysis":
-      return { kind: "analyze", domain: "website", scores, confidence };
-    case "system_analysis":
-      return { kind: "analyze", domain: "system", scores, confidence };
-    case "debugging":
-      return { kind: "debug", scores, confidence };
-    case "file_generation":
-      return { kind: "file", scores, confidence };
-    case "operator":
-      return { kind: "operator", scores, confidence };
-    case "coding":
-      return { kind: "coding", scores, confidence };
-    default:
-      return { kind: "chat", scores, confidence };
-  }
-}
-
-function classifyTask(raw, session) {
-  const intent = detectIntent(raw, session);
-
-  if (intent.kind === "followup") {
-    return {
-      type: intent.activeTask.type,
-      role: intent.activeTask.role,
-      output: intent.activeTask.output,
-      reason: "active_task_carryover",
-      followup: true
-    };
-  }
-
-  switch (intent.kind) {
-    case "build":
-      return { type: "website_builder", role: "website_builder", output: "file", reason: "build_intent" };
-    case "browser_capture":
-      return { type: "browser_capture", role: "web_ui", output: "file", reason: "browser_capture" };
-    case "file":
-      return { type: "file_generation", role: "artifact", output: "file", reason: "file_request" };
-    case "analyze":
-      return intent.domain === "website"
-        ? { type: "analysis", role: "web_ui", output: "analysis", reason: "website_analysis" }
-        : { type: "analysis", role: "research", output: "analysis", reason: "system_analysis" };
-    case "debug":
-      return { type: "debugging", role: "dev", output: "analysis", reason: "debug" };
-    case "operator":
-      return { type: "operator", role: "operator", output: "plan", reason: "operator" };
-    case "coding":
-      return { type: "coding", role: "dev", output: "code", reason: "coding" };
-    case "install":
-      return { type: "installation", role: "installer", output: "action", reason: "install" };
-    default:
-      return { type: "chat", role: "default", output: "text", reason: "default" };
-  }
-}
-
-function classifyTaskDetailed(raw, session) {
-  const task = classifyTask(raw, session);
-  const intent = detectIntent(raw, session);
-  return {
-    task,
-    scores: intent.scores || {},
-    confidence: intent.confidence || 0
-  };
-}
-
-function buildCorePrompt() {
-  return [
-    "Du bist BLUN KING, entwickelt von Mayk Biletti und dem Team von BLUN.",
-    "Antworte klar, direkt, menschlich und ohne Bot-Floskeln.",
-    "Sag zuerst die eigentliche Antwort und bleibe technisch belastbar.",
-    "Einfache Fragen kurz beantworten. Komplexe Themen strukturiert, aber ohne Leerlauf.",
-    "Erfinde nichts. Markiere Unsicherheit sauber.",
-    "Wenn Dateien erzeugt werden sollen, liefere echte Dateien statt Platzhaltertext.",
-    "Du arbeitest in einer lokalen Runtime mit Shell-Zugriff, lokalem Dateisystem, lokalem Speicher, lokalen Installationen und optionalen Referenz-Inspektionen uber Fetch, Screenshots und Browser-Automation.",
-    "Behaupte niemals, du hattest keinen Zugriff auf lokale Tools, Dateien, Installationen oder Shell-Befehle.",
-    "User schreiben oft mit Tippfehlern, Umgangssprache und kaputten Saetzen. Erkenne den beabsichtigten Intent trotzdem korrekt und robust.",
-    "Wenn der Intent klar und lokal ausfuehrbar ist, handle zuerst statt lange zu diskutieren.",
-    "Stelle Rueckfragen nur bei echten externen Blockern wie fehlenden Tokens, Logins, Zielsystemen oder Rechten."
-  ].join("\n");
-}
-
-function rolePrompt(role) {
-  const map = {
-    default: "Rolle: Premium-Chat. Kurz, direkt, hilfreich.",
-    dev: "Rolle: Senior Developer. Technisch, konkret, ohne Marketing-Sprache.",
-    operator: "Rolle: Operator. Priorisieren, Abhangigkeiten erkennen, klare nachste Schritte.",
-    critic: "Rolle: Critic. Nur echte Schwachen und klare Verbesserungen.",
-    support: "Rolle: Support. Ruhig, klar, losungsorientiert.",
-    web_ui: "Rolle: Web/UI Analytiker. Ziel der Seite verstehen, Hierarchie, Conversion, Schwachen.",
-    website_builder: "Rolle: Website Builder. Sofort bauen. Referenzen nur als Stilquelle. Immer echte HTML/CSS-Dateien liefern.",
-    artifact: "Rolle: Artifact Builder. Erzeuge Dateien oder andere nutzbare Artefakte statt Chat-Text.",
-    research: "Rolle: Research. Finde das Relevante, ordne Beobachtungen und leite klare Schlusse ab.",
-    installer: "Rolle: Installer. Fuehre lokale Installationen, Setup-Schritte und Verifikationen direkt aus statt darueber zu reden."
-  };
-  return map[role] || map.default;
-}
-
-function outputContract(output) {
-  const map = {
-    text: "Output: normaler Text. Direkt, kopierbar, kein Meta-Gelaber.",
-    code: "Output: nur der notige Code oder klare Dateianderungen. Keine unnotige Erklarung.",
-    file: "Output: echte Dateien oder Artefakte erzeugen und verifizieren.",
-    analysis: "Output: klare Analyse mit Starken, Schwachen, Risiken und bester Verbesserung.",
-    plan: "Output: Prioritaten, Abhangigkeiten, nachster sinnvoller Schritt.",
-    action: "Output: fuehre die lokale Aktion direkt aus und bestaetige knapp das Ergebnis."
-  };
-  return map[output] || map.text;
-}
-
-function resolveIdentity(raw, task, session, preferredIdentity) {
-  if (preferredIdentity) {
-    return getIdentity(preferredIdentity);
-  }
-
-  const explicit = findIdentityInText(raw);
-  if (explicit) return explicit;
-
-  if (session?.activeTask?.identityId) {
-    return getIdentity(session.activeTask.identityId);
-  }
-
-  return recommendIdentity(task);
-}
-
-function composeSystemPrompt(task, session, rawMessage = "", preferredIdentity) {
-  const identity = resolveIdentity(rawMessage, task, session, preferredIdentity);
-  const parts = [
-    buildCorePrompt(),
-    rolePrompt(task.role),
-    outputContract(task.output),
-    `Identitaet: ${identity.name}. ${identity.prompt}`
-  ];
-  const websiteBuilderRules = path.join(__dirname, "website_builder.txt");
-
-  if (task.type === "website_builder" && fs.existsSync(websiteBuilderRules)) {
-    parts.push(fs.readFileSync(websiteBuilderRules, "utf8"));
-  }
-
-  if (session?.activeTask && task.followup) {
-    parts.push(`Aktiver Task-Kontext: ${JSON.stringify(session.activeTask)}`);
-  }
-
-  return parts.join("\n\n");
-}
-
-function estimateTokens(input = "") {
-  return Math.max(1, Math.ceil(String(input).length / 4));
-}
-
-function scoreResponse(answer, task, userMessage = "") {
-  const reasons = [];
-  let score = 100;
-  const text = String(answer || "");
-  const user = normalize(userMessage);
-
-  if (task.type === "chat" && /^(was ist|was bedeutet|ja oder nein|brauch ich|kennst du)\b/.test(user) && text.length > 500) {
-    score -= 30;
-    reasons.push("too_long_for_simple_question");
-  }
-
-  if (/(certainly|absolutely|gerne helfe ich dir|basierend auf deiner anfrage|als ki)/i.test(text)) {
-    score -= 25;
-    reasons.push("bot_phrasing");
-  }
-
-  if (task.type === "debugging") {
-    const match = String(userMessage).match(/\b(TypeError|ReferenceError|SyntaxError|Error)\b/i);
-    if (match && !text.includes(match[1])) {
-      score -= 10;
-      reasons.push("error_not_repeated");
-    }
-  }
-
-  if (task.type === "website_builder") {
-    const hasFiles = /(index\.html|style\.css|write_file|create_project|<html|<!doctype)/i.test(text);
-    if (!hasFiles) {
-      score -= 40;
-      reasons.push("no_real_build_output");
-    }
-  }
-
-  if (task.type === "installation") {
-    if (/(<!doctype|<html|<body|landingpage|tailwindcss|hero section)/i.test(text) || /(python-telegram-bot|bot\.py|dotenv|applicationbuilder)/i.test(text)) {
-      score -= 60;
-      reasons.push("action_mismatch");
-    }
-    if (/(hast du bereits ein repository|schick mir den code|gib mir den link|welche sprache nutzt du)/i.test(text)) {
-      score -= 35;
-      reasons.push("refusal_or_detour");
-    }
-  }
-
-  if (task.type === "browser_capture") {
-    if (!/(screenshot|bild|png|erstellt|gespeichert)/i.test(text)) {
-      score -= 45;
-      reasons.push("action_mismatch");
-    }
-  }
-
-  return { score: Math.max(0, score), reasons };
-}
-
-function selfCheckResponse(answer, task, userMessage = "") {
-  const quality = scoreResponse(answer, task, userMessage);
-  const criticalReasons = ["action_mismatch", "refusal_or_detour", "no_real_build_output"];
-  const critical = quality.reasons.some((reason) => criticalReasons.includes(reason));
-  const blocked = task.type !== "chat" && (critical || quality.score < 70);
-
-  return {
-    ...quality,
-    blocked,
-    critical,
-    summary: blocked
-      ? "Antwort vor Ausgabe blockiert, weil sie nicht sauber zum Intent oder Output-Vertrag passt."
-      : "Antwort ist konsistent zum Task."
-  };
-}
-
-function buildBlockedActionReply(task, reasons = []) {
-  if (task.type === "installation") {
-    return "Die Modellantwort wurde blockiert, weil sie nicht zur Installationsaufgabe passte. Fuehre stattdessen die Installation direkt oder ueber den Install-Task aus.";
-  }
-  if (task.type === "browser_capture") {
-    return "Die Modellantwort wurde blockiert, weil statt eines Screenshots nur Text erzeugt wurde. Nutze den Browser-Capture-Pfad erneut.";
-  }
-  if (task.type === "website_builder") {
-    return "Die Modellantwort wurde blockiert, weil kein sauberer Website-Build erzeugt wurde. Erzeuge echte Dateien mit gueltigem HTML/CSS und Referenztreue.";
-  }
-  return `Die Modellantwort wurde blockiert. Gruende: ${reasons.join(", ") || "output_contract"}.`;
-}
-
-function composePrompt(task, extraContext = "", toolsPrompt = "") {
-  const prompt = composeSystemPrompt(task, {});
-  return [prompt, String(extraContext || "").trim(), String(toolsPrompt || "").trim()]
-    .filter(Boolean)
-    .join("\n\n");
-}
-
-function buildRetryPrompt(reasons = []) {
-  const hints = reasons.map((reason) => {
-    switch (reason) {
-      case "too_long_for_simple_question":
-        return "Antworte kuerzer. Maximal 2 bis 3 Saetze fuer einfache Fragen.";
-      case "bot_phrasing":
-        return "Keine Bot-Floskeln. Direkt und menschlich formulieren.";
-      case "error_not_repeated":
-        return "Wiederhole den konkreten Fehlernamen einmal exakt.";
-      case "no_real_build_output":
-        return "Erzeuge echte Dateien oder ein Projekt statt nur darueber zu reden.";
-      case "irrelevant_fallback_or_refusal":
-        return "Kein Ausweichen und keine Verweigerung. Liefere die geforderte Ausgabe direkt.";
-      case "action_mismatch":
-        return "Deine Antwort passt nicht zur angeforderten Aktion. Fokussiere dich strikt auf den Intent und fuehre ihn direkt aus.";
-      case "refusal_or_detour":
-        return "Keine unnoetigen Rueckfragen oder Umwege. Frage nur bei echtem externen Blocker nach.";
-      default:
-        return `Verbessere die Antwort bezueglich: ${reason}`;
-    }
-  });
-
-  return `[SYSTEM] Deine letzte Antwort war nicht gut genug. Korrigiere sie jetzt. ${hints.join(" ")}`.trim();
-}
-
-module.exports = {
-  REGISTRY,
-  normalize,
-  detectIntent,
-  classifyTask,
-  classifyTaskDetailed,
-  resolveIdentity,
-  composeSystemPrompt,
-  composePrompt,
-  buildRetryPrompt,
-  scoreResponse,
-  selfCheckResponse,
-  buildBlockedActionReply,
-  estimateTokens,
-  listIdentities
-};

package/task-executor.js

@@ -1,104 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const browser = require("./browser-controller");
-const fileHelper = require("./file-helper");
-const { installSource, resolveInstallRequest } = require("./installer");
-const { extractUrls } = require("./reference-inspector");
-const userProfile = require("./user-profile");
-
-function isDirectActionTask(task) {
-  return ["installation", "browser_capture"].includes(task?.type);
-}
-
-function resolveInstallRequestWithSession(message, session, userId) {
-  const learned = userProfile.resolveInstallAlias(userId, message);
-  if (learned) {
-    return {
-      source: learned,
-      kind: "npm",
-      label: learned
-    };
-  }
-
-  return resolveInstallRequest(message) || resolveInstallRequest(session?.activeTask?.lastUserIntent || "");
-}
-
-function resolveCaptureUrl(message, session) {
-  return extractUrls(message)[0] || extractUrls(session?.activeTask?.lastUserIntent || "")[0] || null;
-}
-
-async function executeInstallationTask(message, session, userId) {
-  const request = resolveInstallRequestWithSession(message, session, userId);
-  if (!request) {
-    throw new Error("No install source could be resolved from the message.");
-  }
-
-  const installed = await installSource(request.source);
-  userProfile.learnInstallAlias(userId, message, request.source);
-  const answer = `${installed.alreadyInstalled ? "Bereits installiert" : "Installiert"}: ${request.label || request.source}`;
-
-  return {
-    status: "completed",
-    answer,
-    install: installed,
-    steps: [
-      { step: 1, action: "intent_detected", detail: "installation" },
-      { step: 2, action: "install_target_resolved", detail: request.source },
-      { step: 3, action: installed.alreadyInstalled ? "already_installed" : "installed", detail: installed.target }
-    ]
-  };
-}
-
-async function executeBrowserCaptureTask(message, session, workdir) {
-  const url = resolveCaptureUrl(message, session);
-  if (!url) {
-    throw new Error("No website URL found for screenshot capture.");
-  }
-
-  fs.mkdirSync(workdir, { recursive: true });
-  await browser.open(url);
-  try {
-    const shotName = `website-shot-${Date.now()}.png`;
-    const shotPath = path.join(workdir, shotName);
-    await browser.screenshot(shotPath);
-    const snapshot = await browser.snapshot();
-    const artifact = fileHelper.writeArtifact(shotName, fs.readFileSync(shotPath));
-
-    return {
-      status: "completed",
-      answer: `Screenshot der Webseite erstellt: ${shotName}`,
-      steps: [
-        { step: 1, action: "intent_detected", detail: "browser_capture" },
-        { step: 2, action: "browser_opened", detail: url },
-        { step: 3, action: "screenshot_written", files: [shotName] }
-      ],
-      files: [{ path: shotName, content: "" }],
-      references: [{ url, title: snapshot.title, screenshotPath: shotPath }],
-      artifact: {
-        artifact_id: artifact.artifact_id,
-        filename: artifact.filename,
-        download: `/download/${artifact.artifact_id}`
-      },
-      snapshot
-    };
-  } finally {
-    await browser.close().catch(() => {});
-  }
-}
-
-async function executeDirectTask({ task, message, session, workdir }) {
-  if (task?.type === "installation") {
-    return executeInstallationTask(message, session, session?.id);
-  }
-  if (task?.type === "browser_capture") {
-    return executeBrowserCaptureTask(message, session, workdir);
-  }
-  throw new Error(`Task ${task?.type || "unknown"} is not a direct action task.`);
-}
-
-module.exports = {
-  isDirectActionTask,
-  resolveInstallRequestWithSession,
-  resolveCaptureUrl,
-  executeDirectTask
-};