@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/installer-PXZJG256.js

@@ -0,0 +1,298 @@
+import {
+  resolvePackageRoot
+} from "./chunk-WPAXAOHD.js";
+import "./chunk-GNHN5HRQ.js";
+import {
+  EXE_HOOK_FILES,
+  textHasLegacySplitPostToolHook
+} from "./chunk-L3TB7CC3.js";
+import {
+  buildMcpHttpHeaders,
+  mcpHttpUrl
+} from "./chunk-YJSP5PPG.js";
+import "./chunk-URLH7ZVR.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-XABJRAUW.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-PH6VRRFR.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/adapters/opencode/installer.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import os from "os";
+
+// src/adapters/opencode/plugin-template.ts
+var PLUGIN_TEMPLATE = `
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+
+const PACKAGE_ROOT = "__PACKAGE_ROOT__";
+const HOOKS_DIR = path.join(PACKAGE_ROOT, "dist", "hooks");
+
+function hookPath(name) {
+  return path.join(HOOKS_DIR, name);
+}
+
+function getAgentEnv() {
+  return {
+    AGENT_ID: process.env.AGENT_ID || process.env.EXE_AGENT_ID || "default",
+    AGENT_ROLE: process.env.AGENT_ROLE || process.env.EXE_AGENT_ROLE || "employee",
+    EXE_OS_DIR: process.env.EXE_OS_DIR || path.join(process.env.HOME || "", ".exe-os"),
+  };
+}
+
+/**
+ * Spawn a hook script with JSON on stdin, return parsed stdout.
+ * Times out after the given ms. Returns null on failure.
+ */
+function runHook(scriptName, payload, timeoutMs = 10000) {
+  return new Promise((resolve) => {
+    try {
+      const child = spawn("node", [hookPath(scriptName)], {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: { ...process.env, ...getAgentEnv() },
+        timeout: timeoutMs,
+      });
+
+      let stdout = "";
+      child.stdout.on("data", (chunk) => { stdout += chunk; });
+      child.on("close", () => {
+        try {
+          resolve(stdout.trim() ? JSON.parse(stdout) : null);
+        } catch {
+          resolve(null);
+        }
+      });
+      child.on("error", () => resolve(null));
+
+      child.stdin.write(JSON.stringify(payload));
+      child.stdin.end();
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+/**
+ * Spawn a hook script fire-and-forget (detached, no stdout capture).
+ * Used for ingestion workers that do background DB writes.
+ */
+function fireHook(scriptName, payload) {
+  try {
+    const child = spawn("node", [hookPath(scriptName)], {
+      detached: true,
+      stdio: ["pipe", "ignore", "ignore"],
+      env: { ...process.env, ...getAgentEnv() },
+    });
+    child.stdin.write(JSON.stringify(payload));
+    child.stdin.end();
+    child.unref();
+  } catch {
+    // Silent \u2014 hooks must never crash the host
+  }
+}
+
+export const ExeOsPlugin = async ({ project, directory }) => {
+  const cwd = directory || process.cwd();
+
+  return {
+    // --- Session start: inject memory brief ---
+    "session.created": async (input) => {
+      const payload = {
+        session_id: input?.sessionId || randomUUID(),
+        cwd,
+        hook_event_name: "SessionStart",
+        source: "startup",
+        model: input?.model || "unknown",
+      };
+      const result = await runHook("session-start.js", payload, 10000);
+      if (result?.hookSpecificOutput?.additionalContext) {
+        // Return context to be injected as system message
+        return result.hookSpecificOutput.additionalContext;
+      }
+    },
+
+    // --- Pre tool use: safety checks ---
+    "tool.execute.before": async (input, output) => {
+      const toolName = input?.metadata?.name || input?.tool || "unknown";
+      const payload = {
+        session_id: input?.sessionId || "opencode",
+        cwd,
+        hook_event_name: "PreToolUse",
+        tool_name: toolName,
+        tool_input: output?.args || input?.args || {},
+        tool_use_id: input?.toolUseId || randomUUID(),
+        transcript_path: "",
+        permission_mode: "dangerously-skip-permissions",
+      };
+      const result = await runHook("pre-tool-use.js", payload, 5000);
+      if (result?.hookSpecificOutput?.permissionDecision === "deny") {
+        // Block the tool call
+        output.denied = true;
+        output.reason = result.hookSpecificOutput.permissionDecisionReason || "Blocked by exe-os";
+      }
+    },
+
+    // --- Post tool use: memory ingestion + error recall ---
+    "tool.execute.after": async (input) => {
+      const toolName = input?.metadata?.name || input?.tool || "unknown";
+      const payload = {
+        session_id: input?.sessionId || "opencode",
+        cwd,
+        hook_event_name: "PostToolUse",
+        tool_name: toolName,
+        tool_input: input?.args || {},
+        tool_response: input?.result || {},
+        tool_use_id: input?.toolUseId || randomUUID(),
+        transcript_path: "",
+        permission_mode: "dangerously-skip-permissions",
+      };
+
+      // Combined hook: runs memory ingestion + error recall in the same
+      // orchestrator used by Claude Code and Codex. This prevents duplicate
+      // PostToolUse pipelines and keeps error-recall output formatting in one
+      // place.
+      const result = await runHook("post-tool-combined.js", payload, 10000);
+      if (result?.hookSpecificOutput?.additionalContext) {
+        return result.hookSpecificOutput.additionalContext;
+      }
+    },
+
+    // --- Message updated: entity boost ---
+    "message.updated": async (input) => {
+      // Only fire for user messages (prompts), not assistant responses
+      const role = input?.message?.role || input?.role;
+      if (role !== "user") return;
+
+      const prompt = input?.message?.content || input?.content || "";
+      if (typeof prompt !== "string" || prompt.length < 10) return;
+
+      const payload = {
+        session_id: input?.sessionId || "opencode",
+        cwd,
+        hook_event_name: "UserPromptSubmit",
+        prompt,
+      };
+      const result = await runHook("prompt-submit.js", payload, 5000);
+      if (result?.hookSpecificOutput?.additionalContext) {
+        return result.hookSpecificOutput.additionalContext;
+      }
+    },
+
+    // --- Session idle: capture response ---
+    "session.idle": async (input) => {
+      const lastMessage = input?.lastMessage || input?.message || "";
+      if (typeof lastMessage !== "string" || lastMessage.length < 100) return;
+
+      const payload = {
+        session_id: input?.sessionId || "opencode",
+        cwd,
+        hook_event_name: "Stop",
+        last_assistant_message: lastMessage,
+        stop_hook_active: true,
+        transcript_path: "",
+      };
+      fireHook("stop.js", payload);
+    },
+  };
+};
+`;
+
+// src/adapters/opencode/installer.ts
+async function registerOpenCodeMcp(packageRoot, homeDir = os.homedir()) {
+  void packageRoot;
+  const configDir = path.join(homeDir, ".config", "opencode");
+  const configPath = path.join(configDir, "opencode.json");
+  await mkdir(configDir, { recursive: true });
+  let config = {};
+  if (existsSync(configPath)) {
+    try {
+      config = JSON.parse(await readFile(configPath, "utf-8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.mcp) {
+    config.mcp = {};
+  }
+  const newEntry = {
+    type: "remote",
+    url: mcpHttpUrl(),
+    headers: buildMcpHttpHeaders(homeDir),
+    enabled: true
+  };
+  const current = config.mcp["exe-os"];
+  if (current && JSON.stringify(current) === JSON.stringify(newEntry)) {
+    return false;
+  }
+  config.mcp["exe-os"] = newEntry;
+  if (!config.$schema) {
+    config.$schema = "https://opencode.ai/config.json";
+  }
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  return true;
+}
+async function installOpenCodePlugin(packageRoot, homeDir = os.homedir()) {
+  const pluginDir = path.join(homeDir, ".config", "opencode", "plugins");
+  const pluginPath = path.join(pluginDir, "exe-os.mjs");
+  await mkdir(pluginDir, { recursive: true });
+  const pluginContent = PLUGIN_TEMPLATE.replace(
+    /__PACKAGE_ROOT__/g,
+    packageRoot.replace(/\\/g, "\\\\")
+  );
+  if (existsSync(pluginPath)) {
+    const existing = await readFile(pluginPath, "utf-8");
+    if (existing === pluginContent) {
+      return false;
+    }
+  }
+  await writeFile(pluginPath, pluginContent);
+  return true;
+}
+function verifyOpenCodeHooks(homeDir = os.homedir()) {
+  const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
+  if (!existsSync(configPath)) return false;
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!config.mcp?.["exe-os"]?.enabled) return false;
+  } catch {
+    return false;
+  }
+  if (!existsSync(pluginPath)) return false;
+  try {
+    const plugin = readFileSync(pluginPath, "utf-8");
+    if (!plugin.includes(EXE_HOOK_FILES.postToolCombined)) return false;
+    if (textHasLegacySplitPostToolHook(plugin)) return false;
+  } catch {
+    return false;
+  }
+  return true;
+}
+async function runOpenCodeInstaller(homeDir) {
+  const packageRoot = resolvePackageRoot();
+  const mcpChanged = await registerOpenCodeMcp(packageRoot, homeDir);
+  process.stderr.write(
+    `[exe-os] OpenCode MCP: ${mcpChanged ? "registered" : "already registered"}
+`
+  );
+  const pluginChanged = await installOpenCodePlugin(packageRoot, homeDir);
+  process.stderr.write(
+    `[exe-os] OpenCode plugin: ${pluginChanged ? "installed" : "already installed"}
+`
+  );
+}
+export {
+  installOpenCodePlugin,
+  registerOpenCodeMcp,
+  runOpenCodeInstaller,
+  verifyOpenCodeHooks
+};

package/dist/lib/cloud-sync.js

@@ -47,19 +47,25 @@ import {
   pushToPostgres,
   recordRosterDeletion,
   shouldUseCrdtMergeForCloudSync
-} from "../chunk-EN4D3BCA.js";
-import "../chunk-T2USDSC2.js";
-import "../chunk-6GQMQJE2.js";
+} from "../chunk-YLKS7KKC.js";
+import "../chunk-ZDPU3JTF.js";
+import "../chunk-FNHYH5U6.js";
 import "../chunk-LO6L5ADL.js";
-import "../chunk-OQ336FHE.js";
+import "../chunk-F5OWHPRG.js";
+import "../chunk-QGGH7LOU.js";
+import "../chunk-NTWF4DAF.js";
+import "../chunk-QOZQ2MYZ.js";
+import "../chunk-YHJPTIPR.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-OTVEIJUQ.js";
-import "../chunk-PUGKVPCC.js";
+import "../chunk-FZB73QOI.js";
 import "../chunk-Y25OJWOQ.js";
 import "../chunk-MP2AFCGL.js";
-import "../chunk-I3IW6AAX.js";
+import "../chunk-HCCG67BY.js";
+import "../chunk-7L2EV3XX.js";
+import "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";

package/dist/lib/consolidation.js

@@ -11,20 +11,20 @@ import {
   selectUnconsolidated,
   storeConsolidation,
   sweepExpiredTraces
-} from "../chunk-I4JYP7CK.js";
-import "../chunk-6OAAN25C.js";
-import "../chunk-GUMRIUI5.js";
+} from "../chunk-GRSYAHKI.js";
+import "../chunk-EDMVA3PT.js";
 import "../chunk-I7AW4237.js";
+import "../chunk-GUMRIUI5.js";
 import "../chunk-EJIF4FNT.js";
-import "../chunk-OQ336FHE.js";
+import "../chunk-YHJPTIPR.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-OTVEIJUQ.js";
-import "../chunk-PUGKVPCC.js";
+import "../chunk-FZB73QOI.js";
 import "../chunk-Y25OJWOQ.js";
 import "../chunk-MP2AFCGL.js";
-import "../chunk-I3IW6AAX.js";
+import "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";

package/dist/lib/database.js

@@ -12,10 +12,11 @@ import {
   initTurso,
   isInitialized,
   offloadReadQuery,
-  setExternalClient
-} from "../chunk-I3IW6AAX.js";
+  setExternalClient,
+  tryGetRawClient
+} from "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";
@@ -36,5 +37,6 @@ export {
   initTurso,
   isInitialized,
   offloadReadQuery,
-  setExternalClient
+  setExternalClient,
+  tryGetRawClient
 };

package/dist/lib/db-daemon-client.js

@@ -1,211 +1,20 @@
 import {
-  deserializeResultSet,
-  serializeValue
-} from "../chunk-QGGH7LOU.js";
-import {
-  connectEmbedDaemon,
-  isClientConnected,
-  sendDaemonRequest
-} from "../chunk-W3EQ362K.js";
+  createDaemonDbClient,
+  initDaemonDbClient,
+  isTransientDaemonTransportError,
+  retryOnDaemonTransportError
+} from "../chunk-F5OWHPRG.js";
+import "../chunk-QGGH7LOU.js";
+import "../chunk-NTWF4DAF.js";
 import "../chunk-QOZQ2MYZ.js";
-import "../chunk-7T7Y56HW.js";
+import "../chunk-HCCG67BY.js";
 import "../chunk-7L2EV3XX.js";
 import "../chunk-R36FAN53.js";
 import "../chunk-LYH5HE24.js";
 import "../chunk-MLKGABMK.js";
-
-// src/lib/db-daemon-client.ts
-function normalizeStatement(stmt) {
-  if (typeof stmt === "string") {
-    return { sql: stmt, args: [] };
-  }
-  const sql = stmt.sql;
-  let args = [];
-  if (Array.isArray(stmt.args)) {
-    args = stmt.args.map((v) => serializeValue(v));
-  } else if (stmt.args && typeof stmt.args === "object") {
-    const named = {};
-    for (const [key, val] of Object.entries(stmt.args)) {
-      named[key] = serializeValue(val);
-    }
-    return { sql, args: named };
-  }
-  return { sql, args };
-}
-function isReadOnlySql(sql) {
-  const normalized = sql.replace(/^\s*--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim().toLowerCase();
-  return /^(select|pragma\s+(?!wal_checkpoint|journal_mode|synchronous|user_version)|with\b.*\bselect\b)/s.test(normalized);
-}
-function createDaemonDbClient(fallbackClient) {
-  let _useDaemon = false;
-  const isMcpProcess = () => process.env.EXE_MCP_MODE === "1";
-  const isTransportError = (errMsg) => errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed" || errMsg === "DB not initialized" || errMsg === "Connection closed" || errMsg === "Server shutting down";
-  async function ensureDaemonRoute() {
-    if (_useDaemon && isClientConnected()) return true;
-    const connected = await connectEmbedDaemon().catch(() => false);
-    if (connected) {
-      _useDaemon = true;
-      return true;
-    }
-    return false;
-  }
-  function unavailableForMcp(errMsg) {
-    const suffix = errMsg ? ` Last transport error: ${errMsg}.` : "";
-    return new Error(
-      "Daemon unavailable for MCP DB operation. Refusing direct SQLite fallback from MCP process to preserve the single-writer gate and prevent FTS5 corruption." + suffix
-    );
-  }
-  const client = {
-    // Daemon-routed clients cannot span a transaction across requests —
-    // BEGIN/COMMIT via execute() is rejected by the daemon SQL guard.
-    // Callers that need atomic multi-statement writes must use batch()
-    // (executed atomically daemon-side). See store.ts flushBatch.
-    // @ts-expect-error -- capability marker consumed by flushBatch
-    interactiveTransactions: false,
-    async execute(stmt) {
-      const daemonReady = await ensureDaemonRoute();
-      if (!daemonReady) {
-        if (isMcpProcess()) throw unavailableForMcp();
-        return fallbackClient.execute(stmt);
-      }
-      const { sql, args } = normalizeStatement(stmt);
-      let response = await sendDaemonRequest({
-        type: "db-execute",
-        sql,
-        args
-      });
-      if (response.error) {
-        const errMsg = String(response.error);
-        if (isTransportError(errMsg) && isReadOnlySql(sql)) {
-          _useDaemon = false;
-          if (await ensureDaemonRoute()) {
-            response = await sendDaemonRequest({ type: "db-execute", sql, args });
-            if (!response.error && response.db) {
-              return deserializeResultSet(response.db);
-            }
-          }
-          if (isMcpProcess()) throw unavailableForMcp(errMsg);
-          process.stderr.write(`[db-daemon] Transport error (${errMsg}), falling back to direct
-`);
-          return fallbackClient.execute(stmt);
-        }
-        if (isTransportError(errMsg)) {
-          _useDaemon = false;
-          throw new Error(`Daemon transport error after write request; refusing unsafe retry: ${errMsg}`);
-        }
-        throw new Error(errMsg);
-      }
-      if (response.db) {
-        return deserializeResultSet(response.db);
-      }
-      if (isMcpProcess()) throw unavailableForMcp("Unexpected daemon response shape");
-      if (!isReadOnlySql(sql)) {
-        throw new Error("Unexpected daemon response after write request; refusing unsafe direct fallback");
-      }
-      process.stderr.write("[db-daemon] Unexpected response shape, falling back to direct\n");
-      return fallbackClient.execute(stmt);
-    },
-    async batch(stmts, mode) {
-      const daemonReady = await ensureDaemonRoute();
-      if (!daemonReady) {
-        if (isMcpProcess()) throw unavailableForMcp();
-        return fallbackClient.batch(stmts, mode);
-      }
-      const statements = stmts.map(normalizeStatement);
-      let response = await sendDaemonRequest({
-        type: "db-batch",
-        statements,
-        mode: mode ?? "deferred"
-      });
-      if (response.error) {
-        const errMsg = String(response.error);
-        const readOnlyBatch = statements.every((s) => isReadOnlySql(s.sql));
-        if (isTransportError(errMsg) && readOnlyBatch) {
-          _useDaemon = false;
-          if (await ensureDaemonRoute()) {
-            response = await sendDaemonRequest({
-              type: "db-batch",
-              statements,
-              mode: mode ?? "deferred"
-            });
-            const retriedResults = response["db-batch"];
-            if (!response.error && retriedResults) {
-              return retriedResults.map(deserializeResultSet);
-            }
-          }
-          if (isMcpProcess()) throw unavailableForMcp(errMsg);
-          process.stderr.write(`[db-daemon] Batch transport error (${errMsg}), falling back to direct
-`);
-          return fallbackClient.batch(stmts, mode);
-        }
-        if (isTransportError(errMsg)) {
-          _useDaemon = false;
-          throw new Error(`Daemon transport error after write batch; refusing unsafe retry: ${errMsg}`);
-        }
-        throw new Error(errMsg);
-      }
-      const batchResults = response["db-batch"];
-      if (batchResults) {
-        return batchResults.map(deserializeResultSet);
-      }
-      if (isMcpProcess()) throw unavailableForMcp("Unexpected daemon batch response shape");
-      if (!statements.every((s) => isReadOnlySql(s.sql))) {
-        throw new Error("Unexpected daemon response after write batch; refusing unsafe direct fallback");
-      }
-      process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
-      return fallbackClient.batch(stmts, mode);
-    },
-    // Transaction support — delegate to fallback (transactions need direct connection)
-    async transaction(mode) {
-      return fallbackClient.transaction(mode);
-    },
-    // executeMultiple — delegate to fallback (used only for schema migrations)
-    async executeMultiple(sql) {
-      return fallbackClient.executeMultiple(sql);
-    },
-    // migrate — delegate to fallback
-    async migrate(stmts) {
-      return fallbackClient.migrate(stmts);
-    },
-    // Sync mode — delegate to fallback
-    sync() {
-      return fallbackClient.sync();
-    },
-    close() {
-      _useDaemon = false;
-    },
-    get closed() {
-      return fallbackClient.closed;
-    },
-    get protocol() {
-      return fallbackClient.protocol;
-    }
-  };
-  return {
-    ...client,
-    /** Enable daemon routing (call after confirming daemon is connected) */
-    _enableDaemon() {
-      _useDaemon = true;
-    },
-    /** Check if daemon routing is active */
-    _isDaemonActive() {
-      return _useDaemon && isClientConnected();
-    }
-  };
-}
-async function initDaemonDbClient(fallbackClient) {
-  if (process.env.EXE_IS_DAEMON === "1") return null;
-  const connected = await connectEmbedDaemon();
-  const client = createDaemonDbClient(fallbackClient);
-  if (connected) {
-    client._enableDaemon();
-    process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
-  } else {
-    process.stderr.write("[db-daemon] Daemon unavailable at init \u2014 will retry lazily\n");
-  }
-  return client;
-}
 export {
   createDaemonDbClient,
-  initDaemonDbClient
+  initDaemonDbClient,
+  isTransientDaemonTransportError,
+  retryOnDaemonTransportError
 };

package/dist/lib/db.js

@@ -12,10 +12,11 @@ import {
   initTurso,
   isInitialized,
   offloadReadQuery,
-  setExternalClient
-} from "../chunk-I3IW6AAX.js";
+  setExternalClient,
+  tryGetRawClient
+} from "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";
@@ -36,5 +37,6 @@ export {
   initTurso,
   isInitialized,
   offloadReadQuery,
-  setExternalClient
+  setExternalClient,
+  tryGetRawClient
 };

package/dist/lib/embedder.js

@@ -6,10 +6,10 @@ import {
   embedDirect,
   getEmbedder,
   prepareEmbeddingText
-} from "../chunk-HGZITN22.js";
-import "../chunk-W3EQ362K.js";
+} from "../chunk-RBFZCHVB.js";
+import "../chunk-NTWF4DAF.js";
 import "../chunk-QOZQ2MYZ.js";
-import "../chunk-7T7Y56HW.js";
+import "../chunk-HCCG67BY.js";
 import "../chunk-7L2EV3XX.js";
 import "../chunk-FXU7JOXK.js";
 import "../chunk-R36FAN53.js";

package/dist/lib/employee-templates.js

@@ -10,12 +10,12 @@ import {
   getTemplateByRole,
   personalizePrompt,
   renderClientCOOTemplate
-} from "../chunk-O4QLYWMC.js";
-import "../chunk-SWOGQD57.js";
+} from "../chunk-3G3ECFB5.js";
+import "../chunk-W77GRCNA.js";
 import "../chunk-VUH67PT4.js";
-import "../chunk-I3IW6AAX.js";
+import "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";

package/dist/lib/employees.js

@@ -28,9 +28,9 @@ import {
   saveEmployees,
   shouldAutoInstance,
   validateEmployeeName
-} from "../chunk-I3IW6AAX.js";
+} from "../chunk-V6LOEOXG.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-2DWYR2LJ.js";
+import "../chunk-VWUQFZFB.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";

package/dist/lib/exe-daemon-client.js

@@ -8,9 +8,9 @@ import {
   pingDaemon,
   sendDaemonRequest,
   sendIngestRequest
-} from "../chunk-W3EQ362K.js";
+} from "../chunk-NTWF4DAF.js";
 import "../chunk-QOZQ2MYZ.js";
-import "../chunk-7T7Y56HW.js";
+import "../chunk-HCCG67BY.js";
 import "../chunk-7L2EV3XX.js";
 import "../chunk-R36FAN53.js";
 import "../chunk-LYH5HE24.js";