background-agents 0.1.2 → 1.0.0

package/app/dist/preload.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+// src/preload.ts
+var import_electron = require("electron");
+import_electron.contextBridge.exposeInMainWorld("electron", {
+  // Platform info
+  platform: process.platform,
+  // Notifications
+  showNotification: (options) => {
+    import_electron.ipcRenderer.send("show-notification", options);
+  },
+  // Badge count
+  updateBadge: (count) => {
+    import_electron.ipcRenderer.send("update-badge", count);
+  },
+  // Window control
+  toggleWindow: () => {
+    import_electron.ipcRenderer.send("toggle-window");
+  },
+  // Auth token (secure storage)
+  getAuthToken: () => import_electron.ipcRenderer.invoke("get-auth-token"),
+  setAuthToken: (token) => import_electron.ipcRenderer.invoke("set-auth-token", token),
+  // External links
+  openExternal: (url) => {
+    import_electron.ipcRenderer.send("open-external", url);
+  },
+  // Local repo sync (Backgrounder folder)
+  getGitSyncSettings: () => import_electron.ipcRenderer.invoke("git-sync:get-settings"),
+  setGitSyncSettings: (settings) => import_electron.ipcRenderer.invoke("git-sync:set-settings", settings),
+  pickSyncDirectory: () => import_electron.ipcRenderer.invoke("git-sync:pick-directory"),
+  getRepoSyncState: (repo) => import_electron.ipcRenderer.invoke("git-sync:get-repo-state", repo),
+  openRepoFolder: (data) => import_electron.ipcRenderer.invoke("git-sync:open-repo-folder", data),
+  setActiveChat: (data) => import_electron.ipcRenderer.invoke("git-sync:set-active-chat", data),
+  syncBranch: (data) => import_electron.ipcRenderer.invoke("git-sync:sync-branch", data),
+  // License auto-detection
+  getClaudeLicenseAutoDetect: () => import_electron.ipcRenderer.invoke("get-claude-license-auto-detect"),
+  getLicenseDetectSettings: () => import_electron.ipcRenderer.invoke("get-license-detect-settings"),
+  setLicenseDetectSettings: (settings) => import_electron.ipcRenderer.invoke("set-license-detect-settings", settings),
+  // Event listeners
+  onDeepLink: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("deep-link", handler);
+    return () => import_electron.ipcRenderer.removeListener("deep-link", handler);
+  },
+  onNavigateToChat: (callback) => {
+    const handler = (_event, chatId) => callback(chatId);
+    import_electron.ipcRenderer.on("navigate-to-chat", handler);
+    return () => import_electron.ipcRenderer.removeListener("navigate-to-chat", handler);
+  },
+  onGitPushed: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("git-pushed", handler);
+    return () => import_electron.ipcRenderer.removeListener("git-pushed", handler);
+  },
+  onShortcut: (callback) => {
+    const handler = (_event, action) => callback(action);
+    import_electron.ipcRenderer.on("shortcut", handler);
+    return () => import_electron.ipcRenderer.removeListener("shortcut", handler);
+  },
+  onSyncStatus: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("sync-status", handler);
+    return () => import_electron.ipcRenderer.removeListener("sync-status", handler);
+  },
+  onSyncError: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("sync-error", handler);
+    return () => import_electron.ipcRenderer.removeListener("sync-error", handler);
+  }
+});

package/bin/background-agents.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+"use strict";
+
+// Background Agents desktop launcher.
+//
+// `npx background-agents` resolves the latest published version of this package,
+// then this script spawns the bundled Electron app (packages/launcher/app),
+// pointed at the production backend by default. The heavy Electron runtime is a
+// normal npm dependency, so npm/npx downloads it (with its own progress bar) on
+// first run and caches it for subsequent launches.
+
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const { spawn } = require("child_process");
+
+const { colors, symbols, Spinner, line, showCursor } = require("../lib/ui");
+const pkg = require("../package.json");
+
+const PROD_URL = "https://backgrounder.dev";
+const DEV_URL = "http://localhost:4000";
+const APP_ENTRY = path.join(__dirname, "..", "app", "dist", "main.js");
+const READY_MARKER = "background-agents:ready";
+
+function parseArgs(argv) {
+  const opts = {
+    url: null,
+    dev: false,
+    verbose: false,
+    help: false,
+    version: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") opts.help = true;
+    else if (arg === "-v" || arg === "--version") opts.version = true;
+    else if (arg === "--dev") opts.dev = true;
+    else if (arg === "--verbose") opts.verbose = true;
+    else if (arg === "--url") opts.url = argv[++i];
+    else if (arg.startsWith("--url=")) opts.url = arg.slice("--url=".length);
+  }
+  return opts;
+}
+
+function printBanner() {
+  line();
+  line(
+    `  ${colors.bold(colors.magenta("Background Agents"))} ${colors.dim(
+      "desktop launcher v" + pkg.version
+    )}`
+  );
+  line(`  ${colors.dim("https://backgrounder.dev")}`);
+  line();
+}
+
+function printHelp() {
+  printBanner();
+  line(`  ${colors.bold("Usage")}`);
+  line(`    npx ${pkg.name} [options]`);
+  line();
+  line(`  ${colors.bold("Options")}`);
+  line(`    --url <url>     Backend URL to load (default: ${PROD_URL})`);
+  line(`    --dev          Use the local dev server (${DEV_URL})`);
+  line(`    --verbose      Stream the desktop app's logs to this terminal`);
+  line(`    -v, --version  Print the launcher version`);
+  line(`    -h, --help     Show this help`);
+  line();
+  line(`  ${colors.bold("Environment")}`);
+  line(`    BACKGROUND_AGENTS_URL   Same as --url (the --url flag wins)`);
+  line();
+  line(
+    `  ${colors.dim(
+      "Tip: run `npx " + pkg.name + "@latest` to always get the newest version."
+    )}`
+  );
+  line();
+}
+
+// The `electron` package returns the absolute path to its binary when required
+// from a normal Node process (i.e. not from inside Electron itself).
+function resolveElectron() {
+  let electronPath;
+  try {
+    electronPath = require("electron");
+  } catch (_err) {
+    return {
+      error:
+        "Electron runtime is not installed. Reinstall with: npx " +
+        pkg.name +
+        "@latest",
+    };
+  }
+  if (typeof electronPath !== "string" || !fs.existsSync(electronPath)) {
+    return {
+      error:
+        "The Electron binary is missing or its download was skipped.\n" +
+        "  Reinstall without ELECTRON_SKIP_BINARY_DOWNLOAD set, e.g.: npx background-agents@latest",
+    };
+  }
+  return { electronPath };
+}
+
+// Non-blocking check of the npm registry for a newer launcher version.
+function checkLatestVersion(timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}/latest`,
+      { headers: { accept: "application/json" }, timeout: timeoutMs },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data).version || null);
+          } catch (_err) {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+function semverGt(a, b) {
+  const pa = String(a).split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return true;
+    if (pa[i] < pb[i]) return false;
+  }
+  return false;
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    printHelp();
+    return;
+  }
+  if (opts.version) {
+    line(pkg.version);
+    return;
+  }
+
+  printBanner();
+
+  if (!fs.existsSync(APP_ENTRY)) {
+    line(
+      `  ${symbols.error} ${colors.red(
+        "App bundle is missing — this package was built incorrectly."
+      )}`
+    );
+    line(`  ${colors.dim("Expected: " + APP_ENTRY)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const { electronPath, error } = resolveElectron();
+  if (error) {
+    line(`  ${symbols.error} ${colors.red(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const backendUrl =
+    opts.url ||
+    (opts.dev ? DEV_URL : process.env.BACKGROUND_AGENTS_URL || PROD_URL);
+
+  const latestPromise = checkLatestVersion();
+
+  const spinner = new Spinner();
+  spinner.start(`Launching Background Agents ${colors.dim("→ " + backendUrl)}`);
+
+  const env = Object.assign({}, process.env, {
+    BACKGROUND_AGENTS_URL: backendUrl,
+    // Avoid Electron attaching to / spawning a console window on Windows.
+    ELECTRON_NO_ATTACH_CONSOLE: "1",
+  });
+
+  const child = spawn(electronPath, [APP_ENTRY], {
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: false,
+  });
+
+  let ready = false;
+  let exited = false;
+
+  function announceRunning() {
+    if (ready) return;
+    ready = true;
+    clearTimeout(readyFallback);
+    spinner.succeed(
+      `Background Agents is running ${colors.dim("→ " + backendUrl)}`
+    );
+    line(
+      `  ${colors.dim("Close the app window (or press Ctrl+C here) to quit.")}`
+    );
+    latestPromise.then((latest) => {
+      if (!exited && latest && semverGt(latest, pkg.version)) {
+        line();
+        line(
+          `  ${symbols.info} ${colors.yellow(
+            "A newer version is available"
+          )} ${colors.dim("(" + pkg.version + " → " + latest + ")")}`
+        );
+        line(
+          `  ${colors.dim("Update with: ")}${colors.cyan(
+            "npx " + pkg.name + "@latest"
+          )}`
+        );
+      }
+    });
+  }
+
+  function handleOutput(buffer, stream) {
+    const text = buffer.toString();
+    if (text.includes(READY_MARKER)) announceRunning();
+    if (opts.verbose) {
+      const cleaned = text.split(READY_MARKER).join("").replace(/\n{2,}/g, "\n");
+      if (cleaned.trim()) stream.write(colors.dim(cleaned));
+    }
+  }
+
+  child.stdout.on("data", (b) => handleOutput(b, process.stdout));
+  child.stderr.on("data", (b) => handleOutput(b, process.stderr));
+
+  // Fallback: if the app never prints the ready marker (older build, or output
+  // buffered), assume it's up after a short grace period so the UI doesn't hang.
+  const readyFallback = setTimeout(announceRunning, 8000);
+  if (readyFallback.unref) readyFallback.unref();
+
+  let shuttingDown = false;
+  function shutdown(signal) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearTimeout(readyFallback);
+    try {
+      child.kill(signal || "SIGTERM");
+    } catch (_err) {
+      /* ignore */
+    }
+  }
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+  child.on("error", (err) => {
+    exited = true;
+    clearTimeout(readyFallback);
+    if (!ready) spinner.fail("Failed to launch Background Agents");
+    showCursor();
+    line(`  ${symbols.error} ${colors.red(err.message)}`);
+    process.exitCode = 1;
+  });
+
+  child.on("exit", (code, signal) => {
+    exited = true;
+    clearTimeout(readyFallback);
+    showCursor();
+    if (!ready) {
+      spinner.fail("Background Agents exited before it finished starting");
+      if (code) {
+        line(
+          `  ${colors.dim(
+            "The app exited with code " +
+              code +
+              ". Re-run with --verbose to see its logs."
+          )}`
+        );
+      }
+    } else {
+      line(`  ${symbols.arrow} ${colors.dim("Background Agents closed.")}`);
+    }
+    process.exitCode = signal ? 0 : code == null ? 0 : code;
+  });
+}
+
+try {
+  main();
+} catch (err) {
+  showCursor();
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exitCode = 1;
+}

package/lib/ui.js

@@ -0,0 +1,110 @@
+"use strict";
+
+// Tiny dependency-free terminal UI: colors + a spinner. Keeping this free of
+// npm deps means `npx background-agents` installs fast (only Electron is heavy).
+
+const useColor =
+  process.env.NO_COLOR == null &&
+  process.env.TERM !== "dumb" &&
+  (Boolean(process.stdout.isTTY) || process.env.FORCE_COLOR != null);
+
+function wrap(open, close) {
+  return (s) => (useColor ? `[${open}m${s}[${close}m` : String(s));
+}
+
+const colors = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39),
+};
+
+const symbols = {
+  success: colors.green("✔"),
+  error: colors.red("✖"),
+  warn: colors.yellow("⚠"),
+  info: colors.cyan("ℹ"),
+  arrow: colors.gray("›"),
+  bullet: colors.gray("•"),
+};
+
+const isTTY = Boolean(process.stdout.isTTY);
+
+const HIDE_CURSOR = "[?25l";
+const SHOW_CURSOR = "[?25h";
+const CLEAR_LINE = "\r";
+
+function showCursor() {
+  if (isTTY) process.stdout.write(SHOW_CURSOR);
+}
+
+class Spinner {
+  constructor() {
+    this.frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    this.index = 0;
+    this.timer = null;
+    this.text = "";
+  }
+
+  start(text) {
+    this.text = text;
+    if (!isTTY) {
+      process.stdout.write(`  ${text}\n`);
+      return this;
+    }
+    if (this.timer) return this;
+    process.stdout.write(HIDE_CURSOR);
+    this.render();
+    this.timer = setInterval(() => this.render(), 80);
+    if (this.timer.unref) this.timer.unref();
+    return this;
+  }
+
+  render() {
+    const frame = colors.cyan(this.frames[this.index]);
+    this.index = (this.index + 1) % this.frames.length;
+    process.stdout.write(`${CLEAR_LINE}  ${frame} ${this.text}`);
+  }
+
+  update(text) {
+    this.text = text;
+    if (!isTTY) process.stdout.write(`  ${text}\n`);
+    return this;
+  }
+
+  stop(symbol, text) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    const message = text != null ? text : this.text;
+    const line = `  ${symbol} ${message}`;
+    if (isTTY) process.stdout.write(`${CLEAR_LINE}${line}\n${SHOW_CURSOR}`);
+    else process.stdout.write(`${line}\n`);
+    return this;
+  }
+
+  succeed(text) {
+    return this.stop(symbols.success, text);
+  }
+  fail(text) {
+    return this.stop(symbols.error, text);
+  }
+  warn(text) {
+    return this.stop(symbols.warn, text);
+  }
+  info(text) {
+    return this.stop(symbols.info, text);
+  }
+}
+
+function line(text = "") {
+  process.stdout.write(`${text}\n`);
+}
+
+module.exports = { colors, symbols, Spinner, line, isTTY, showCursor };

package/package.json

@@ -1,68 +1,42 @@
 {
   "name": "background-agents",
-  "version": "0.1.2",
-  "description": "A TypeScript SDK for interacting with various AI coding agents (Claude, Codex, OpenCode, Gemini, Pi)",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "type": "module",
+  "version": "1.0.0",
+  "description": "Launch the Background Agents desktop app with one command — npx background-agents. Always runs the latest published version.",
+  "type": "commonjs",
+  "bin": {
+    "background-agents": "bin/background-agents.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "app",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
-    "build": "npm run build:eliza && tsc",
-    "build:eliza": "npm run build:eliza-bundle && npm run build:eliza-embed",
-    "build:eliza-bundle": "esbuild src/agents/eliza/cli.ts --bundle --platform=node --format=esm --outfile=dist/agents/eliza/cli.bundle.js",
-    "build:eliza-embed": "npx tsx scripts/embed-eliza-bundle.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts",
-    "clean": "rm -rf dist",
-    "prepublishOnly": "npm run build",
-    "generate:jsonl-refs": "npx tsx scripts/generate-jsonl-references.ts"
+    "bundle": "node scripts/bundle-app.mjs",
+    "prepack": "node scripts/bundle-app.mjs",
+    "start": "node bin/background-agents.js",
+    "typecheck": "node --check bin/background-agents.js && node --check lib/ui.js"
+  },
+  "dependencies": {
+    "electron": "^33.2.1"
   },
   "keywords": [
-    "ai",
-    "coding-agent",
-    "claude",
-    "codex",
-    "opencode",
-    "gemini",
-    "pi",
-    "sdk"
+    "background-agents",
+    "electron",
+    "launcher",
+    "npx",
+    "desktop"
   ],
-  "author": "",
   "license": "MIT",
+  "author": "James Murdza",
+  "homepage": "https://backgrounder.dev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jamesmurdza/upstream-agents.git",
-    "directory": "packages/agents"
-  },
-  "homepage": "https://github.com/jamesmurdza/upstream-agents/tree/main/packages/agents",
-  "bugs": {
-    "url": "https://github.com/jamesmurdza/upstream-agents/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "esbuild": "^0.20.0",
-    "typescript": "^5.3.0",
-    "vitest": "^1.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "next.config.codeagentsdk.cjs"
-  ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./*": "./src/*",
-    "./next.config": "./next.config.codeagentsdk.cjs"
-  },
-  "dependencies": {
-    "@daytonaio/sdk": "^0.150.0",
-    "dotenv": "^17.3.1"
+    "url": "https://github.com/jamesmurdza/background-agents.git",
+    "directory": "packages/launcher"
   }
 }

package/dist/agents/claude/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Claude Code CLI Agent Definition
- */
-import type { AgentDefinition } from "../../core/agent";
-/**
- * Claude Code CLI agent definition.
- *
- * Interacts with the Claude CLI tool which outputs JSON lines in stream-json format.
- */
-export declare const claudeAgent: AgentDefinition;
-//# sourceMappingURL=index.d.ts.map

package/dist/agents/claude/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAyC,MAAM,kBAAkB,CAAA;AAwC9F;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,eAqDzB,CAAA"}

package/dist/agents/claude/index.js

@@ -1,78 +0,0 @@
-/**
- * Claude Code CLI Agent Definition
- */
-import { parseClaudeLine } from "./parser";
-import { CLAUDE_TOOL_MAPPINGS } from "./tools";
-/** Claude credentials directory */
-const CLAUDE_CREDENTIALS_DIR = "/home/daytona/.claude";
-/** Claude credentials file */
-const CLAUDE_CREDENTIALS_FILE = "/home/daytona/.claude/.credentials.json";
-/** Environment variable name for Claude Code credentials */
-const CLAUDE_CODE_CREDENTIALS_ENV = "CLAUDE_CODE_CREDENTIALS";
-/**
- * Claude agent-specific setup: write credentials from environment variable.
- *
- * When CLAUDE_CODE_CREDENTIALS environment variable is set, this function
- * writes its contents to ~/.claude/.credentials.json. This allows credentials
- * to be passed via environment variable instead of writing the file manually.
- *
- * The value should be the JSON content of the credentials file, e.g.:
- * {"claudeAiOauth":{"accessToken":"sk-ant-oa..."}}
- */
-async function claudeSetup(sandbox, env) {
-    const credentialsJson = env[CLAUDE_CODE_CREDENTIALS_ENV];
-    if (!credentialsJson || !sandbox.executeCommand)
-        return;
-    // Escape single quotes for shell command
-    const safeCredentials = credentialsJson.replace(/'/g, "'\\''");
-    // Create directory and write credentials file with secure permissions
-    await sandbox.executeCommand(`mkdir -p '${CLAUDE_CREDENTIALS_DIR}' && echo '${safeCredentials}' > '${CLAUDE_CREDENTIALS_FILE}' && chmod 600 '${CLAUDE_CREDENTIALS_FILE}'`, 30);
-}
-/**
- * Claude Code CLI agent definition.
- *
- * Interacts with the Claude CLI tool which outputs JSON lines in stream-json format.
- */
-export const claudeAgent = {
-    name: "claude",
-    toolMappings: CLAUDE_TOOL_MAPPINGS,
-    capabilities: {
-        supportsSystemPrompt: true,
-        supportsResume: true,
-        setup: claudeSetup,
-    },
-    buildCommand(options) {
-        const args = [];
-        // Print mode for non-interactive usage
-        args.push("-p");
-        // Add output format flag for JSON streaming (requires --verbose)
-        args.push("--output-format", "stream-json", "--verbose");
-        // Skip permission prompts when already running in a sandbox
-        args.push("--dangerously-skip-permissions");
-        // Apply system prompt via native CLI flag when provided
-        if (options.systemPrompt) {
-            args.push("--system-prompt", options.systemPrompt);
-        }
-        // Add model if specified (e.g., "sonnet", "opus", "claude-sonnet-4-5-20250929")
-        if (options.model) {
-            args.push("--model", options.model);
-        }
-        // Resume session if provided
-        if (options.sessionId) {
-            args.push("--resume", options.sessionId);
-        }
-        // Add the prompt if provided
-        if (options.prompt) {
-            args.push(options.prompt);
-        }
-        return {
-            cmd: "claude",
-            args,
-            env: options.env,
-        };
-    },
-    parse(line, _context) {
-        return parseClaudeLine(line, this.toolMappings);
-    },
-};
-//# sourceMappingURL=index.js.map

package/dist/agents/claude/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/agents/claude/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAE9C,mCAAmC;AACnC,MAAM,sBAAsB,GAAG,uBAAuB,CAAA;AACtD,8BAA8B;AAC9B,MAAM,uBAAuB,GAAG,yCAAyC,CAAA;AACzE,4DAA4D;AAC5D,MAAM,2BAA2B,GAAG,yBAAyB,CAAA;AAE7D;;;;;;;;;GASG;AACH,KAAK,UAAU,WAAW,CACxB,OAAyB,EACzB,GAA2B;IAE3B,MAAM,eAAe,GAAG,GAAG,CAAC,2BAA2B,CAAC,CAAA;IACxD,IAAI,CAAC,eAAe,IAAI,CAAC,OAAO,CAAC,cAAc;QAAE,OAAM;IAEvD,yCAAyC;IACzC,MAAM,eAAe,GAAG,eAAe,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IAE9D,sEAAsE;IACtE,MAAM,OAAO,CAAC,cAAc,CAC1B,aAAa,sBAAsB,cAAc,eAAe,QAAQ,uBAAuB,mBAAmB,uBAAuB,GAAG,EAC5I,EAAE,CACH,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAoB;IAC1C,IAAI,EAAE,QAAQ;IAEd,YAAY,EAAE,oBAAoB;IAElC,YAAY,EAAE;QACZ,oBAAoB,EAAE,IAAI;QAC1B,cAAc,EAAE,IAAI;QACpB,KAAK,EAAE,WAAW;KACnB;IAED,YAAY,CAAC,OAAmB;QAC9B,MAAM,IAAI,GAAa,EAAE,CAAA;QAEzB,uCAAuC;QACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEf,iEAAiE;QACjE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,aAAa,EAAE,WAAW,CAAC,CAAA;QAExD,4DAA4D;QAC5D,IAAI,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAA;QAE3C,wDAAwD;QACxD,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;QACpD,CAAC;QAED,gFAAgF;QAChF,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAClB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;QACrC,CAAC;QAED,6BAA6B;QAC7B,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;QAC1C,CAAC;QAED,6BAA6B;QAC7B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO;YACL,GAAG,EAAE,QAAQ;YACb,IAAI;YACJ,GAAG,EAAE,OAAO,CAAC,GAAG;SACjB,CAAA;IACH,CAAC;IAED,KAAK,CAAC,IAAY,EAAE,QAAsB;QACxC,OAAO,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IACjD,CAAC;CACF,CAAA"}