@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/tui-data-SB45REYU.js

@@ -0,0 +1,161 @@
+import {
+  init_task_scope,
+  sessionScopeFilter
+} from "./chunk-N7L33TED.js";
+import "./chunk-NEAHEC5G.js";
+import "./chunk-KRLOFIPI.js";
+import "./chunk-R4M6XCMU.js";
+import "./chunk-TYLF4LSW.js";
+import "./chunk-PJHHFJAN.js";
+import "./chunk-YOQKMB6N.js";
+import "./chunk-JT76KRZQ.js";
+import "./chunk-6M5II4EV.js";
+import "./chunk-HP43GLZ6.js";
+import "./chunk-ELE2C7L4.js";
+import "./chunk-WZQ4CPRG.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import "./chunk-4NYQAS33.js";
+import "./chunk-OFK72LTZ.js";
+import "./chunk-6BFIFI5F.js";
+import "./chunk-RUG3N6P4.js";
+import "./chunk-IRQTM7DY.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/lib/tui-data.ts
+init_database();
+init_task_scope();
+async function loadMemoryDashboard(limit) {
+  const client = getClient();
+  const [countResult, recentResult, agentResult] = await Promise.all([
+    client.execute("SELECT COUNT(*) as cnt FROM memories"),
+    client.execute({
+      sql: "SELECT agent_id, tool_name, project_name, raw_text, timestamp FROM memories ORDER BY timestamp DESC LIMIT ?",
+      args: [limit]
+    }),
+    client.execute("SELECT agent_id, COUNT(*) as cnt FROM memories GROUP BY agent_id ORDER BY cnt DESC")
+  ]);
+  return {
+    total: Number(countResult.rows[0]?.cnt ?? 0),
+    recent: recentResult.rows.map((row) => ({
+      agentId: String(row.agent_id ?? "unknown"),
+      toolName: String(row.tool_name ?? ""),
+      projectName: String(row.project_name ?? ""),
+      rawText: String(row.raw_text ?? ""),
+      timestamp: String(row.timestamp ?? "")
+    })),
+    byAgent: agentResult.rows.map((row) => ({
+      agentId: String(row.agent_id ?? "unknown"),
+      count: Number(row.cnt ?? 0)
+    }))
+  };
+}
+async function loadTeamBadgeCounts() {
+  const client = getClient();
+  const memoryCounts = /* @__PURE__ */ new Map();
+  const memResult = await client.execute("SELECT agent_id, COUNT(*) as cnt FROM memories GROUP BY agent_id");
+  for (const row of memResult.rows) {
+    memoryCounts.set(String(row.agent_id), Number(row.cnt));
+  }
+  return memoryCounts;
+}
+async function loadTeamDetailMetrics(employeeNames) {
+  const client = getClient();
+  const projectsByEmployee = /* @__PURE__ */ new Map();
+  const currentTaskByEmployee = /* @__PURE__ */ new Map();
+  const scope = sessionScopeFilter();
+  for (const employeeName of employeeNames) {
+    const [projectResult, taskResult] = await Promise.all([
+      client.execute({
+        sql: `SELECT DISTINCT project_name,
+                     MAX(CASE WHEN status = 'in_progress' THEN 1 WHEN status = 'open' THEN 2 ELSE 3 END) as urgency
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open','in_progress','done')${scope.sql}
+              GROUP BY project_name
+              ORDER BY urgency ASC
+              LIMIT 5`,
+        args: [employeeName, ...scope.args]
+      }),
+      client.execute({
+        sql: `SELECT title FROM tasks
+              WHERE assigned_to = ? AND status = 'in_progress'${scope.sql}
+              ORDER BY updated_at DESC
+              LIMIT 1`,
+        args: [employeeName, ...scope.args]
+      })
+    ]);
+    const projects = projectResult.rows.map((row) => {
+      const urgency = Number(row.urgency);
+      return {
+        name: String(row.project_name),
+        status: urgency === 1 ? "active" : urgency === 2 ? "has_tasks" : "idle"
+      };
+    });
+    if (projects.length > 0) projectsByEmployee.set(employeeName, projects);
+    if (taskResult.rows.length > 0) {
+      currentTaskByEmployee.set(employeeName, String(taskResult.rows[0].title));
+    }
+  }
+  return { projectsByEmployee, currentTaskByEmployee };
+}
+async function loadTeamMetrics(employeeNames) {
+  const [memoryCounts, { projectsByEmployee, currentTaskByEmployee }] = await Promise.all([
+    loadTeamBadgeCounts(),
+    loadTeamDetailMetrics(employeeNames)
+  ]);
+  return { memoryCounts, projectsByEmployee, currentTaskByEmployee };
+}
+async function loadTaskList() {
+  const client = getClient();
+  const scope = sessionScopeFilter();
+  const result = await client.execute({
+    sql: `SELECT id, title, priority, assigned_to, assigned_by, status, project_name, created_at, result
+          FROM tasks
+          WHERE 1=1${scope.sql}
+          ORDER BY
+            CASE status WHEN 'in_progress' THEN 0 WHEN 'open' THEN 1 WHEN 'blocked' THEN 2 WHEN 'needs_review' THEN 3 WHEN 'done' THEN 4 ELSE 5 END,
+            CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+            created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id ?? ""),
+    title: String(row.title ?? ""),
+    priority: String(row.priority ?? "p2").toUpperCase(),
+    assignedTo: String(row.assigned_to ?? ""),
+    assignedBy: String(row.assigned_by ?? ""),
+    status: String(row.status ?? "open"),
+    projectName: String(row.project_name ?? ""),
+    createdAt: String(row.created_at ?? ""),
+    result: String(row.result ?? "")
+  }));
+}
+async function searchWikiMemoryRows(query) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, timestamp, project_name
+          FROM memories
+          WHERE raw_text LIKE ? AND COALESCE(status, 'active') = 'active'
+          ORDER BY timestamp DESC LIMIT 20`,
+    args: [`%${query}%`]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    rawText: String(row.raw_text),
+    timestamp: String(row.timestamp),
+    projectName: String(row.project_name ?? "")
+  }));
+}
+export {
+  loadMemoryDashboard,
+  loadTaskList,
+  loadTeamBadgeCounts,
+  loadTeamDetailMetrics,
+  loadTeamMetrics,
+  searchWikiMemoryRows
+};

package/dist/update-check-LZGZISRJ.js

@@ -0,0 +1,11 @@
+import {
+  checkForUpdate,
+  getLocalVersion,
+  getRemoteVersion
+} from "./chunk-MZIGUUDQ.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  checkForUpdate,
+  getLocalVersion,
+  getRemoteVersion
+};

package/dist/webhook-VVP7KQVC.js

@@ -0,0 +1,96 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/gateway/adapters/webhook.ts
+import { randomUUID } from "crypto";
+var SEND_TIMEOUT_MS = 1e4;
+function resolvePath(obj, path) {
+  let current = obj;
+  for (const segment of path.split(".")) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+var WebhookAdapter = class {
+  platform = "webhook";
+  responseUrl = "";
+  fieldMap = { text: "text", senderId: "from", channelId: "channel" };
+  messageHandler = null;
+  connected = false;
+  async connect(config) {
+    const { response_url, field_map } = config.credentials;
+    if (!field_map) {
+      throw new Error(
+        "Webhook adapter requires field_map in credentials (JSON string with text, senderId paths)"
+      );
+    }
+    this.responseUrl = response_url ?? "";
+    try {
+      this.fieldMap = typeof field_map === "string" ? JSON.parse(field_map) : field_map;
+    } catch {
+      throw new Error("field_map must be a valid JSON string with text and senderId paths");
+    }
+    if (!this.fieldMap.text || !this.fieldMap.senderId) {
+      throw new Error("field_map must include at least 'text' and 'senderId' paths");
+    }
+    this.connected = true;
+    console.log("[webhook] Generic webhook adapter connected");
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  /**
+   * Inject a raw webhook payload. Normalizes using configured field mappings
+   * and calls the registered message handler.
+   */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const text = String(resolvePath(rawPayload, this.fieldMap.text) ?? "");
+    const senderId = String(resolvePath(rawPayload, this.fieldMap.senderId) ?? "");
+    if (!text || !senderId) return;
+    const channelId = this.fieldMap.channelId ? String(resolvePath(rawPayload, this.fieldMap.channelId) ?? senderId) : senderId;
+    const senderName = this.fieldMap.senderName ? String(resolvePath(rawPayload, this.fieldMap.senderName) ?? "") || void 0 : void 0;
+    const messageId = this.fieldMap.messageId ? String(resolvePath(rawPayload, this.fieldMap.messageId) ?? randomUUID()) : randomUUID();
+    const timestamp = this.fieldMap.timestamp ? String(resolvePath(rawPayload, this.fieldMap.timestamp) ?? (/* @__PURE__ */ new Date()).toISOString()) : (/* @__PURE__ */ new Date()).toISOString();
+    const normalized = {
+      messageId,
+      platform: "webhook",
+      senderId,
+      senderName,
+      channelId,
+      chatType: "direct",
+      text,
+      timestamp,
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[webhook] Message handler error:", err);
+    }
+  }
+  async sendText(channelId, text, _options) {
+    if (!this.responseUrl) return;
+    const res = await fetch(this.responseUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channelId, text }),
+      signal: AbortSignal.timeout(SEND_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Webhook send failed (${res.status}): ${errBody}`);
+    }
+  }
+  async sendTyping(_channelId) {
+  }
+  async healthCheck() {
+    return { connected: this.connected };
+  }
+};
+export {
+  WebhookAdapter
+};

package/dist/whatsapp-J6QNDBGY.js

@@ -0,0 +1,9 @@
+import {
+  WhatsAppAdapter,
+  calculateBackoff
+} from "./chunk-BU3ID2WT.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  WhatsAppAdapter,
+  calculateBackoff
+};

package/dist/whatsapp-accounts-RTJF3LM6.js

@@ -0,0 +1,15 @@
+import {
+  _resetCache,
+  getAccountByName,
+  getAccountByPhoneNumberId,
+  getDefaultAccount,
+  loadAccounts
+} from "./chunk-YGAAZN3E.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  _resetCache,
+  getAccountByName,
+  getAccountByPhoneNumberId,
+  getDefaultAccount,
+  loadAccounts
+};

package/dist/wiki-client-EKCIKCVC.js

@@ -0,0 +1,136 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/lib/wiki-client.ts
+var LOCAL_WIKI_URL = process.env.EXE_WIKI_URL || "http://localhost:3001";
+var REQUEST_TIMEOUT_MS = 8e3;
+async function wikiFetch(config, path, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path}`;
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+    } catch {
+      clearTimeout(timeout);
+      const retryController = new AbortController();
+      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS);
+      try {
+        await new Promise((r) => setTimeout(r, 500));
+        response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: retryController.signal
+        });
+      } finally {
+        clearTimeout(retryTimeout);
+      }
+    }
+    if (!response.ok) {
+      throw new Error(`Wiki API ${method} ${path}: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function resolveWikiUrl(configUrl) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`${LOCAL_WIKI_URL}/api/v1/auth`, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok || res.status === 401 || res.status === 403) {
+      return LOCAL_WIKI_URL;
+    }
+  } catch {
+  }
+  if (configUrl && configUrl !== LOCAL_WIKI_URL) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e3);
+      const res = await fetch(`${configUrl}/api/v1/auth`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok || res.status === 401 || res.status === 403) {
+        return configUrl;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function createWikiClient() {
+  const { loadConfig } = await import("./lib/config.js");
+  const config = await loadConfig();
+  const baseUrl = await resolveWikiUrl(config.wikiUrl);
+  if (!baseUrl) return null;
+  return {
+    baseUrl,
+    apiKey: config.wikiApiKey
+  };
+}
+async function listWorkspaces(client) {
+  const data = await wikiFetch(client, "/workspaces");
+  return (data.workspaces ?? []).map((w) => ({
+    slug: w.slug,
+    name: w.name,
+    createdAt: w.createdAt ?? "",
+    threads: w.threads ?? []
+  }));
+}
+async function listDocuments(client, workspaceSlug) {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}`
+  );
+  const docs = Array.isArray(data.workspace) ? data.workspace[0]?.documents ?? [] : [];
+  return docs.map((d) => ({
+    filename: d.filename ?? "untitled",
+    docpath: d.docpath,
+    workspace: workspaceSlug,
+    pinned: d.pinned ?? false
+  }));
+}
+async function chatInWorkspace(client, workspaceSlug, message, mode = "chat") {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}/chat`,
+    "POST",
+    { message, mode }
+  );
+  return {
+    id: data.id ?? "",
+    type: data.type ?? "textResponse",
+    textResponse: data.textResponse ?? "",
+    sources: data.sources ?? [],
+    error: data.error ?? null
+  };
+}
+async function getChatHistory(client, workspaceSlug, limit = 50) {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}/chats?limit=${limit}&orderBy=desc`
+  );
+  return (data.history ?? []).reverse().map((h) => ({
+    role: h.role === "user" ? "user" : "assistant",
+    content: h.content,
+    sentAt: h.sentAt ?? 0
+  }));
+}
+export {
+  chatInWorkspace,
+  createWikiClient,
+  getChatHistory,
+  listDocuments,
+  listWorkspaces
+};

package/dist/worker-gate-UYNN62GJ.js

@@ -0,0 +1,19 @@
+import {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+} from "./chunk-TWYEE4FB.js";
+import "./chunk-KVPG5UT6.js";
+import "./chunk-X2IMCCM5.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  MAX_CONCURRENT_WORKERS,
+  cleanupWorkerPid,
+  registerWorkerPid,
+  releaseBackfillLock,
+  tryAcquireBackfillLock,
+  tryAcquireWorkerSlot
+};

package/dist/worktree-4T4BPWPN.js

@@ -0,0 +1,205 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/lib/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+function getGitRoot(dir) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return realpath(root);
+  } catch {
+    return null;
+  }
+}
+function getMainRepoRoot(dir) {
+  try {
+    const commonDir = execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return realpath(path.dirname(commonDir));
+  } catch {
+    return null;
+  }
+}
+function worktreePath(repoRoot, employeeName, instance) {
+  const label = instanceLabel(employeeName, instance);
+  return path.join(repoRoot, ".worktrees", label);
+}
+function worktreeBranch(employeeName, instance) {
+  return `${instanceLabel(employeeName, instance)}-work`;
+}
+function instanceLabel(name, instance) {
+  return instance != null && instance > 0 ? `${name}${instance}` : name;
+}
+function ensureWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getGitRoot(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    return wtPath;
+  }
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  mkdirSync(worktreesDir, { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  const branchExists = branchExistsLocally(repoRoot, branch);
+  try {
+    if (branchExists) {
+      execSync(`git worktree add "${wtPath}" "${branch}"`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } else {
+      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    return wtPath;
+  } catch (err) {
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function isWorktreeDirty(wtPath) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: wtPath,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return true;
+  }
+}
+function cleanupWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getMainRepoRoot(projectDir);
+  if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (!existsSync(wtPath)) {
+    return { cleaned: false, reason: "worktree does not exist" };
+  }
+  if (isWorktreeDirty(wtPath)) {
+    return { cleaned: false, reason: "worktree has uncommitted changes" };
+  }
+  const mainBranch = detectMainBranch(repoRoot);
+  if (!mainBranch) {
+    return { cleaned: false, reason: "could not determine main branch" };
+  }
+  if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
+  }
+  try {
+    execSync(`git worktree remove "${wtPath}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    return {
+      cleaned: false,
+      reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    execSync(`git branch -d "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
+}
+function branchExistsLocally(repoRoot, branch) {
+  try {
+    execSync(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    if (branchExistsLocally(repoRoot, candidate)) return candidate;
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function ensureGitignoreEntry(repoRoot, entry) {
+  try {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `
+# Agent worktrees (exe-os)
+${entry}
+`);
+    } else {
+    }
+  } catch {
+  }
+}
+export {
+  cleanupWorktree,
+  ensureWorktree,
+  getGitRoot,
+  getMainRepoRoot,
+  isWorktreeDirty,
+  worktreeBranch,
+  worktreePath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.127",
+  "version": "0.9.129",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",