@rubytech/create-maxy-code 0.1.4 → 0.1.6

package/payload/server/{chunk-6YL26HQW.js → chunk-IDKWGLM5.js}

@@ -2483,7 +2483,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve4) => setTimeout(resolve4));
+            await new Promise((resolve6) => setTimeout(resolve6));
             maxReadCount = 3;
             continue;
           }
@@ -2762,10 +2762,10 @@ var SCRYPT_R = 8;
 var SCRYPT_P = 1;
 var SCRYPT_KEYLEN = 64;
 function scryptAsync(password, salt) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     scrypt(password, salt, SCRYPT_KEYLEN, { N: SCRYPT_N, r: SCRYPT_R, p: SCRYPT_P }, (err, key) => {
       if (err) reject(err);
-      else resolve4(key);
+      else resolve6(key);
     });
   });
 }
@@ -3412,45 +3412,551 @@ function parseCookieValue(cookieHeader, name) {
   }
 }
 
+// app/lib/claude-agent/account.ts
+import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync4, readdirSync, existsSync as existsSync4, statSync } from "fs";
+
+// ../lib/brand-templating/src/index.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+var PLACEHOLDER = "{{productName}}";
+var cachedProductName = null;
+function brandJsonPath() {
+  const platformRoot2 = process.env.MAXY_PLATFORM_ROOT;
+  if (!platformRoot2) {
+    throw new Error(
+      "[skill-loader] MAXY_PLATFORM_ROOT not set \u2014 cannot resolve brand.json"
+    );
+  }
+  return join2(platformRoot2, "config", "brand.json");
+}
+function getBrandProductName() {
+  if (cachedProductName !== null) return cachedProductName;
+  const path = brandJsonPath();
+  if (!existsSync3(path)) {
+    throw new Error(`[skill-loader] brand.json missing at ${path}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(path, "utf-8"));
+  } catch (err) {
+    throw new Error(
+      `[skill-loader] brand.json unreadable at ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const value = parsed.productName;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(
+      `[skill-loader] brand.json at ${path} has missing or empty productName`
+    );
+  }
+  cachedProductName = value;
+  return value;
+}
+function substituteBrandPlaceholders(content, sourcePath) {
+  if (!content.includes(PLACEHOLDER)) return content;
+  let productName;
+  try {
+    productName = getBrandProductName();
+  } catch (err) {
+    console.error(
+      `[skill-loader] ERROR: brand.json missing \u2014 cannot resolve productName for skill ${sourcePath}`
+    );
+    throw err;
+  }
+  const occurrences = content.split(PLACEHOLDER).length - 1;
+  const substituted = content.split(PLACEHOLDER).join(productName);
+  console.log(
+    `[skill-loader] brand-substituted productName=${productName} skill=${sourcePath} occurrences=${occurrences}`
+  );
+  return substituted;
+}
+
+// app/lib/claude-agent/account.ts
+var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "..");
+var ACCOUNTS_DIR = resolve3(PLATFORM_ROOT2, "..", "data/accounts");
+if (!existsSync4(PLATFORM_ROOT2)) {
+  throw new Error(
+    `PLATFORM_ROOT does not exist: ${PLATFORM_ROOT2}
+Set the MAXY_PLATFORM_ROOT environment variable to the absolute path of the platform directory.`
+  );
+}
+function resolveAccount() {
+  if (!existsSync4(ACCOUNTS_DIR)) return null;
+  let usersJsonUserId = null;
+  if (existsSync4(USERS_FILE)) {
+    try {
+      const raw2 = readFileSync4(USERS_FILE, "utf-8").trim();
+      if (raw2) {
+        const users = JSON.parse(raw2);
+        if (users.length > 0) {
+          usersJsonUserId = users[0].userId;
+        }
+      }
+    } catch {
+    }
+  }
+  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  let fallback = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const configPath = resolve3(ACCOUNTS_DIR, entry.name, "account.json");
+    if (!existsSync4(configPath)) continue;
+    const raw2 = readFileSync4(configPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(raw2);
+    } catch {
+      console.error(`[maxy] account.json is corrupt at ${configPath} \u2014 skipping`);
+      continue;
+    }
+    if (!config.adminModel || !config.publicModel) {
+      throw new Error(
+        `[maxy] account.json at ${configPath} is missing required model fields (adminModel / publicModel). Update account.json with valid model identifiers.`
+      );
+    }
+    const result = {
+      accountId: config.accountId,
+      accountDir: resolve3(ACCOUNTS_DIR, entry.name),
+      config
+    };
+    if (usersJsonUserId && config.admins?.some((a) => a.userId === usersJsonUserId)) {
+      return result;
+    }
+    if (!fallback) {
+      fallback = result;
+    }
+  }
+  if (usersJsonUserId && fallback) {
+    console.warn(
+      `[maxy] resolveAccount: no account matches users.json userId ${usersJsonUserId} \u2014 falling back to ${fallback.accountId}`
+    );
+  }
+  return fallback;
+}
+function readAgentFile(accountDir, agentName, filename) {
+  const filePath = resolve3(accountDir, "agents", agentName, filename);
+  if (!existsSync4(filePath)) return null;
+  const raw2 = readFileSync4(filePath, "utf-8");
+  if (filename.endsWith(".md")) {
+    return substituteBrandPlaceholders(raw2, filePath);
+  }
+  return raw2;
+}
+var RESERVED_SLUGS = /* @__PURE__ */ new Set(["admin", "api", "assets", "brand", "bot", "privacy"]);
+var SLUG_PATTERN = /^[a-z][a-z0-9-]{2,49}$/;
+function validateAgentSlug(slug) {
+  if (!SLUG_PATTERN.test(slug)) return false;
+  if (RESERVED_SLUGS.has(slug)) return false;
+  return true;
+}
+function resolveDefaultAgentSlug(accountDir) {
+  const configPath = resolve3(accountDir, "account.json");
+  if (!existsSync4(configPath)) {
+    console.error("[agent-resolve] account.json not found \u2014 cannot resolve defaultAgent");
+    return null;
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync4(configPath, "utf-8"));
+  } catch (err) {
+    console.error("[agent-resolve] failed to read account.json:", err);
+    return null;
+  }
+  if (!config.defaultAgent) {
+    console.error("[agent-resolve] defaultAgent not configured in account.json \u2014 set it via the connect-whatsapp skill");
+    return null;
+  }
+  const agentConfigPath = resolve3(accountDir, "agents", config.defaultAgent, "config.json");
+  if (!existsSync4(agentConfigPath)) {
+    console.error(`[agent-resolve] defaultAgent="${config.defaultAgent}" has no config.json at ${agentConfigPath}`);
+    return null;
+  }
+  return config.defaultAgent;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function resolveAgentConfig(accountDir, agentName) {
+  let model = null;
+  let plugins = null;
+  let status = null;
+  let displayName = null;
+  let image = null;
+  let imageShape = null;
+  let showAgentName = false;
+  let liveMemory = false;
+  let knowledgeKeywords = null;
+  let accessMode = "open";
+  const MAX_KNOWLEDGE_KEYWORDS = 5;
+  const configRaw = readAgentFile(accountDir, agentName, "config.json");
+  if (configRaw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(configRaw);
+    } catch {
+      console.warn(`[agent-config] ${agentName}/config.json: invalid JSON \u2014 using defaults`);
+      parsed = {};
+    }
+    model = typeof parsed.model === "string" ? parsed.model : null;
+    plugins = Array.isArray(parsed.plugins) ? parsed.plugins : null;
+    status = typeof parsed.status === "string" ? parsed.status : null;
+    displayName = typeof parsed.displayName === "string" ? parsed.displayName : null;
+    image = typeof parsed.image === "string" ? parsed.image : null;
+    if (typeof parsed.imageShape === "string" && ["circle", "rounded"].includes(parsed.imageShape)) {
+      imageShape = parsed.imageShape;
+    }
+    if (parsed.showAgentName === true) {
+      showAgentName = true;
+    } else if (parsed.showAgentName === "none") {
+      showAgentName = "none";
+    }
+    if (image || imageShape || showAgentName) {
+      console.log(`[agent-config] ${agentName}: image=${image || "(none)"} imageShape=${imageShape || "(none)"} showAgentName=${showAgentName}`);
+    }
+    if (typeof parsed.accessMode === "string" && ["gated", "paid"].includes(parsed.accessMode)) {
+      accessMode = parsed.accessMode;
+    }
+    if (typeof parsed.liveMemory === "boolean") {
+      liveMemory = parsed.liveMemory;
+    } else if (typeof parsed.liveMemory === "string") {
+      const lower = parsed.liveMemory.toLowerCase();
+      if (lower === "true") {
+        liveMemory = true;
+        console.warn(`[agent-config] ${agentName}: liveMemory is string "true" \u2014 coercing to boolean. Fix the config to use a boolean value.`);
+      } else if (lower === "false") {
+        liveMemory = false;
+        console.warn(`[agent-config] ${agentName}: liveMemory is string "false" \u2014 coercing to boolean. Fix the config to use a boolean value.`);
+      } else {
+        throw new Error(`[agent-config] ${agentName}: liveMemory has invalid string value "${parsed.liveMemory}" \u2014 expected boolean or "true"/"false"`);
+      }
+    } else if (parsed.liveMemory !== void 0 && parsed.liveMemory !== null) {
+      throw new Error(`[agent-config] ${agentName}: liveMemory has invalid type ${typeof parsed.liveMemory} \u2014 expected boolean or "true"/"false"`);
+    }
+    if (Array.isArray(parsed.knowledgeKeywords) && parsed.knowledgeKeywords.length > 0) {
+      const filtered = parsed.knowledgeKeywords.filter((k) => typeof k === "string" && k.trim()).map((k) => k.replace(/,/g, "").trim().toLowerCase()).filter(Boolean);
+      if (filtered.length > MAX_KNOWLEDGE_KEYWORDS) {
+        console.warn(`[agent-config] ${agentName}: knowledgeKeywords has ${filtered.length} entries \u2014 capping at ${MAX_KNOWLEDGE_KEYWORDS}`);
+      }
+      knowledgeKeywords = filtered.length > 0 ? filtered.slice(0, MAX_KNOWLEDGE_KEYWORDS) : null;
+    }
+  }
+  let knowledge = null;
+  let knowledgeBaked = false;
+  const agentDir = resolve3(accountDir, "agents", agentName);
+  const knowledgePath = resolve3(agentDir, "KNOWLEDGE.md");
+  const summaryPath = resolve3(agentDir, "KNOWLEDGE-SUMMARY.md");
+  const hasKnowledge = existsSync4(knowledgePath);
+  const hasSummary = existsSync4(summaryPath);
+  if (hasKnowledge && hasSummary) {
+    const knowledgeMtime = statSync(knowledgePath).mtimeMs;
+    const summaryMtime = statSync(summaryPath).mtimeMs;
+    if (summaryMtime >= knowledgeMtime) {
+      knowledge = readFileSync4(summaryPath, "utf-8");
+    } else {
+      console.warn(`[agent-config] ${agentName}: KNOWLEDGE-SUMMARY.md is stale (KNOWLEDGE.md is newer) \u2014 using full knowledge`);
+      knowledge = readFileSync4(knowledgePath, "utf-8");
+    }
+    knowledgeBaked = true;
+  } else if (hasKnowledge) {
+    knowledge = readFileSync4(knowledgePath, "utf-8");
+    knowledgeBaked = true;
+  }
+  let budget = null;
+  const identityRaw = readAgentFile(accountDir, agentName, "IDENTITY.md");
+  const soulRaw = readAgentFile(accountDir, agentName, "SOUL.md");
+  if (identityRaw || soulRaw || knowledge) {
+    const identityTokens = identityRaw ? estimateTokens(identityRaw) : 0;
+    const soulTokens = soulRaw ? estimateTokens(soulRaw) : 0;
+    const knowledgeTokens = knowledge ? estimateTokens(knowledge) : 0;
+    budget = {
+      identity: identityTokens,
+      soul: soulTokens,
+      knowledge: knowledgeTokens,
+      plugins: 0,
+      total: identityTokens + soulTokens + knowledgeTokens
+    };
+  }
+  return { model, plugins, status, displayName, image, imageShape, showAgentName, knowledge, knowledgeBaked, liveMemory, knowledgeKeywords, budget, accessMode };
+}
+function getDefaultAccountId() {
+  return resolveAccount()?.accountId ?? null;
+}
+function resolveUserAccounts(userId) {
+  if (!existsSync4(ACCOUNTS_DIR)) return [];
+  const results = [];
+  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const configPath = resolve3(ACCOUNTS_DIR, entry.name, "account.json");
+    if (!existsSync4(configPath)) continue;
+    let config;
+    try {
+      config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    } catch {
+      console.error(`[session] account.json corrupt at ${configPath} \u2014 skipping`);
+      continue;
+    }
+    const adminEntry = config.admins?.find((a) => a.userId === userId);
+    if (adminEntry) {
+      results.push({
+        accountId: config.accountId,
+        accountDir: resolve3(ACCOUNTS_DIR, entry.name),
+        config,
+        role: adminEntry.role
+      });
+    }
+  }
+  return results;
+}
+
+// app/lib/claude-agent/session-store.ts
+import { createHash } from "crypto";
+var SESSION_TTL_MS2 = 24 * 60 * 60 * 1e3;
+var sessionStore = /* @__PURE__ */ new Map();
+function fingerprintSessionKey(raw2) {
+  if (typeof raw2 !== "string" || !raw2) return raw2;
+  if (/^sk_[a-f0-9]{16}$/.test(raw2)) return raw2;
+  if (!raw2.startsWith("v1.")) return raw2;
+  return `sk_${createHash("sha256").update(raw2).digest("hex").slice(0, 16)}`;
+}
+function registerSession(cacheKey2, agentType, accountId, _unused, userId, userName, role) {
+  const existing = sessionStore.get(cacheKey2);
+  if (existing) {
+    existing.agentType = agentType;
+    existing.accountId = accountId;
+    existing.userId = userId ?? existing.userId;
+    existing.userName = userName ?? existing.userName;
+    existing.role = role ?? existing.role;
+    return;
+  }
+  sessionStore.set(cacheKey2, { agentType, createdAt: Date.now(), accountId, userId, userName, role });
+}
+function validateSession(cacheKey2, agentType, _signedSessionToken) {
+  const session = sessionStore.get(cacheKey2);
+  if (!session) return { ok: false, reason: "session-not-registered" };
+  if (session.agentType !== agentType) return { ok: false, reason: "agent-type-mismatch" };
+  if (Date.now() - session.createdAt > SESSION_TTL_MS2) {
+    sessionStore.delete(cacheKey2);
+    return { ok: false, reason: "session-expired-age" };
+  }
+  return { ok: true };
+}
+function getAccountIdForSession(cacheKey2) {
+  return sessionStore.get(cacheKey2)?.accountId;
+}
+function getUserIdForSession(cacheKey2) {
+  return sessionStore.get(cacheKey2)?.userId;
+}
+function getUserNameForSession(cacheKey2) {
+  return sessionStore.get(cacheKey2)?.userName;
+}
+function getRoleForSession(cacheKey2) {
+  return sessionStore.get(cacheKey2)?.role;
+}
+function getConversationIdForSession(cacheKey2) {
+  return sessionStore.get(cacheKey2)?.conversationId;
+}
+function setConversationIdForSession(cacheKey2, conversationId) {
+  const session = sessionStore.get(cacheKey2);
+  if (!session) return false;
+  session.conversationId = conversationId;
+  return true;
+}
+function setWantsPriorConversation(cacheKey2) {
+  const session = sessionStore.get(cacheKey2);
+  if (session) session.wantsPriorConversation = true;
+}
+function unregisterSession(cacheKey2) {
+  return sessionStore.delete(cacheKey2);
+}
+function getSessionKeyByConversationId(_conversationId) {
+  return void 0;
+}
+
+// app/lib/claude-agent/plugin-manifest.ts
+import { resolve as resolve4, join as join3 } from "path";
+import {
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync2,
+  readdirSync as readdirSync2,
+  existsSync as existsSync5,
+  statSync as statSync2,
+  cpSync
+} from "fs";
+function isMissingPluginDir(pluginDir) {
+  const pluginRoot = resolve4(PLATFORM_ROOT2, "plugins", pluginDir);
+  if (existsSync5(resolve4(pluginRoot, "PLUGIN.md"))) return false;
+  if (existsSync5(resolve4(pluginRoot, "mcp/dist/index.js"))) return false;
+  return true;
+}
+function findMissingPlugins(enabledPlugins) {
+  if (!Array.isArray(enabledPlugins) || enabledPlugins.length === 0) return [];
+  return enabledPlugins.filter(isMissingPluginDir);
+}
+function readBundleSubPlugins(bundlePath) {
+  if (!existsSync5(bundlePath)) return [];
+  let raw2;
+  try {
+    raw2 = readFileSync5(bundlePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const fm = raw2.match(/^---\n([\s\S]*?)\n---/);
+  if (!fm) return [];
+  const subs = [];
+  let inPlugins = false;
+  for (const line of fm[1].split("\n")) {
+    if (/^plugins:/.test(line)) {
+      inPlugins = true;
+      continue;
+    }
+    if (inPlugins) {
+      const m = line.match(/^\s+- (.+)/);
+      if (m) subs.push(m[1].trim());
+      else break;
+    }
+  }
+  return subs;
+}
+function walkPremiumBundles() {
+  if (BRAND_NAME === "maxy") return [];
+  const stagingRoot = resolve4(PLATFORM_ROOT2, "../premium-plugins");
+  if (!existsSync5(stagingRoot)) return [];
+  let entries;
+  try {
+    entries = readdirSync2(stagingRoot);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const bundle of entries) {
+    const bundleDir = resolve4(stagingRoot, bundle);
+    try {
+      if (!statSync2(bundleDir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const declared = readBundleSubPlugins(join3(bundleDir, "BUNDLE.md"));
+    result.push({ bundle, subs: declared.length > 0 ? declared : [bundle] });
+  }
+  return result;
+}
+function autoDeliverPremiumPlugins() {
+  const TAG = "[premium-auto-deliver]";
+  const bundles = walkPremiumBundles();
+  if (bundles.length === 0) return;
+  const stagingRoot = resolve4(PLATFORM_ROOT2, "../premium-plugins");
+  const pluginsDir = resolve4(PLATFORM_ROOT2, "plugins");
+  for (const { bundle, subs } of bundles) {
+    const stagingDir = resolve4(stagingRoot, bundle);
+    const bundlePath = join3(stagingDir, "BUNDLE.md");
+    const isBundle = existsSync5(bundlePath);
+    if (isBundle) {
+      let delivered = 0;
+      let skipped = 0;
+      for (const sub of subs) {
+        const target = resolve4(pluginsDir, sub);
+        if (existsSync5(resolve4(target, "PLUGIN.md"))) {
+          skipped++;
+          continue;
+        }
+        const source = resolve4(stagingDir, "plugins", sub);
+        if (!existsSync5(source)) {
+          console.log(`${TAG} ${bundle}/${sub}: source missing in staging, skipping`);
+          continue;
+        }
+        try {
+          cpSync(source, target, { recursive: true });
+          delivered++;
+        } catch (err) {
+          console.log(`${TAG} ${bundle}/${sub}: copy failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      console.log(`${TAG} ${bundle} (bundle): ${delivered} delivered, ${skipped} already present`);
+    } else {
+      const target = resolve4(pluginsDir, bundle);
+      if (existsSync5(resolve4(target, "PLUGIN.md"))) {
+        console.log(`${TAG} ${bundle}: already present, skipping`);
+      } else {
+        try {
+          cpSync(stagingDir, target, { recursive: true });
+          console.log(`${TAG} ${bundle} (standalone): delivered`);
+        } catch (err) {
+          console.log(`${TAG} ${bundle}: copy failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
+}
+function reconcileEnabledPlugins(accountDir, config) {
+  const TAG = "[premium-auto-deliver]";
+  if (!accountDir || !config) return;
+  const bundles = walkPremiumBundles();
+  const pluginsDir = resolve4(PLATFORM_ROOT2, "plugins");
+  const bundleNames = [];
+  const allSubs = [];
+  for (const { bundle, subs } of bundles) {
+    bundleNames.push(bundle);
+    for (const sub of subs) {
+      if (!existsSync5(resolve4(pluginsDir, sub, "PLUGIN.md"))) continue;
+      allSubs.push(sub);
+    }
+  }
+  const current = Array.isArray(config.enabledPlugins) ? config.enabledPlugins : [];
+  const currentSet = new Set(current);
+  const added = [];
+  for (const sub of allSubs) {
+    if (currentSet.has(sub)) continue;
+    currentSet.add(sub);
+    added.push(sub);
+  }
+  console.log(`${TAG} brand=${BRAND_NAME} bundles=[${bundleNames.join(",")}] subs=[${allSubs.join(",")}] stamped=${added.length}`);
+  if (added.length === 0) return;
+  const merged = [...currentSet];
+  const configPath = resolve4(accountDir, "account.json");
+  try {
+    const raw2 = readFileSync5(configPath, "utf-8");
+    const parsed = JSON.parse(raw2);
+    parsed.enabledPlugins = merged;
+    writeFileSync2(configPath, JSON.stringify(parsed, null, 2) + "\n");
+    config.enabledPlugins = merged;
+  } catch (err) {
+    console.error(`${TAG} enabled-stamp write failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+// app/lib/claude-agent/logging.ts
+var emitMissingOnResolve = (..._args) => null;
+
+// app/lib/claude-agent/spawn-env.ts
+var getBundleMtimeIso = (..._args) => null;
+
+// app/lib/claude-agent/stream-log-writer.ts
+var appendStreamLogLine = (..._args) => null;
+
+// app/lib/claude-agent/summary-helpers.ts
+var stripAttachmentMetaSuffix = (..._args) => null;
+
 // app/lib/claude-agent.ts
 var agentLogStream = (..._args) => null;
 var clearSessionHistory = (..._args) => null;
 var compactSession = (..._args) => null;
 var completeGrantSetup = (..._args) => null;
-var findMissingPlugins = (..._args) => null;
-var fingerprintSessionKey = (..._args) => null;
-var getAccountIdForSession = (..._args) => null;
 var getAgentNameForSession = (..._args) => null;
-var getConversationIdForSession = (..._args) => null;
-var getDefaultAccountId = (..._args) => null;
 var getGrantForSession = (..._args) => null;
 var getGroupSlugForSession = (..._args) => null;
-var getRoleForSession = (..._args) => null;
-var getSessionMessages = (..._args) => null;
 var getStreamLogHandle = (..._args) => null;
-var getUserIdForSession = (..._args) => null;
-var getUserNameForSession = (..._args) => null;
 var getVisitorIdForSession = (..._args) => null;
-var hasStubAccountDir = (..._args) => null;
 var invokeAgent = (..._args) => null;
-var listAdminSessionsInProgress = (..._args) => null;
-var mintAdminSessionToken = (..._args) => null;
+var listAdminSessionsInProgress = (..._args) => [];
 var registerGrantSession = (..._args) => null;
 var registerResumedSession = (..._args) => null;
-var registerSession = (..._args) => null;
-var resolveAccount = (..._args) => null;
-var resolveAgentConfig = (..._args) => null;
-var resolveDefaultAgentSlug = (..._args) => null;
-var resolveUserAccounts = (..._args) => null;
 var setAgentSessionId = (..._args) => null;
-var setConversationIdForSession = (..._args) => null;
 var setGroupContextForSession = (..._args) => null;
-var setWantsPriorConversation = (..._args) => null;
+var getSessionMessages = (..._args) => [];
 var sigtermFlushStreamLogs = (..._args) => null;
 var streamLogPathFor = (..._args) => null;
-var unregisterSession = (..._args) => null;
-var validateAgentSlug = (..._args) => null;
-var validateSession = (..._args) => null;
 
 // server/routes/_helpers.ts
 async function safeJson(c) {
@@ -3577,16 +4083,16 @@ var clientIpMiddleware = async (c, next) => {
 
 // server/lib/action-runner.ts
 import { spawn } from "child_process";
-import { createReadStream, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, statSync, unlinkSync, watch } from "fs";
+import { createReadStream, existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync3, unlinkSync, watch } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2, resolve as resolve3 } from "path";
-import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
 import { setTimeout as delay } from "timers/promises";
 function loadBrandInfo() {
-  const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "..");
-  const brandPath = resolve3(platformRoot2, "config", "brand.json");
+  const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve5(process.cwd(), "..");
+  const brandPath = resolve5(platformRoot2, "config", "brand.json");
   try {
-    const parsed = JSON.parse(readFileSync3(brandPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(brandPath, "utf-8"));
     const hostname = typeof parsed.hostname === "string" && parsed.hostname ? parsed.hostname : "maxy";
     const configDir = typeof parsed.configDir === "string" && parsed.configDir ? parsed.configDir : ".maxy";
     return { hostname, configDir };
@@ -3596,10 +4102,10 @@ function loadBrandInfo() {
 }
 function actionLogDir() {
   const { configDir } = loadBrandInfo();
-  return join2(homedir2(), configDir, "logs", "actions");
+  return join4(homedir2(), configDir, "logs", "actions");
 }
 function actionLogPath(actionId) {
-  return join2(actionLogDir(), `${actionId}.log`);
+  return join4(actionLogDir(), `${actionId}.log`);
 }
 var WHITELIST = {
   upgrade: {
@@ -3637,13 +4143,13 @@ var WHITELIST = {
       if (!idSet && !nameSet) {
         throw new Error("cloudflare-setup: requires tunnelId (operator-selected) OR tunnelName (operator-created)");
       }
-      const scriptPath = join2(homedir2(), "setup-tunnel.sh");
-      if (!existsSync3(scriptPath)) {
+      const scriptPath = join4(homedir2(), "setup-tunnel.sh");
+      if (!existsSync6(scriptPath)) {
         throw new Error(
           `cloudflare-setup: ~/setup-tunnel.sh not found. Re-run the installer to repair the symlink.`
         );
       }
-      const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "..");
+      const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve5(process.cwd(), "..");
       return {
         argv: [scriptPath, ...positional],
         env: {
@@ -3691,12 +4197,12 @@ function actionNameFromId(actionId) {
 }
 function cleanupStaleLogs() {
   const dir = actionLogDir();
-  if (!existsSync3(dir)) return;
+  if (!existsSync6(dir)) return;
   const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-  for (const entry of readdirSync(dir)) {
-    const full = join2(dir, entry);
+  for (const entry of readdirSync3(dir)) {
+    const full = join4(dir, entry);
     try {
-      const st = statSync(full);
+      const st = statSync3(full);
       if (st.isFile() && st.mtimeMs < cutoff) unlinkSync(full);
     } catch {
     }
@@ -3812,10 +4318,10 @@ function extractPhase(text) {
   return null;
 }
 function readLogTailLines(path, tailLines) {
-  if (!existsSync3(path)) return [];
+  if (!existsSync6(path)) return [];
   let raw2;
   try {
-    raw2 = readFileSync3(path, "utf-8");
+    raw2 = readFileSync6(path, "utf-8");
   } catch {
     return [];
   }
@@ -3832,8 +4338,8 @@ async function* streamActionEvents(opts) {
   let byteOffset = opts.fromByteOffset ?? 0;
   const actionName = actionNameFromId(actionId);
   const reconcileFromLog = isKnownAction(actionName) ? WHITELIST[actionName].reconcileFromLog : void 0;
-  if (existsSync3(logPath)) {
-    const snapshot = statSync(logPath).size;
+  if (existsSync6(logPath)) {
+    const snapshot = statSync3(logPath).size;
     if (byteOffset < snapshot) {
       for await (const ev of readLogLines(logPath, byteOffset, snapshot)) {
         const phase = extractPhase(ev.text);
@@ -3860,10 +4366,10 @@ async function* streamActionEvents(opts) {
       r();
     }
   }
-  const watcher = existsSync3(logPath) ? watch(logPath, async () => {
+  const watcher = existsSync6(logPath) ? watch(logPath, async () => {
     if (!watching) return;
     try {
-      const size = statSync(logPath).size;
+      const size = statSync3(logPath).size;
       if (size <= byteOffset) return;
       for await (const ev of readLogLines(logPath, byteOffset, size)) {
         const phase = extractPhase(ev.text);
@@ -4095,44 +4601,52 @@ export {
   renderLoginPage,
   canAccessAdmin,
   parseCookieValue,
+  PLATFORM_ROOT2 as PLATFORM_ROOT,
+  ACCOUNTS_DIR,
+  resolveAccount,
+  validateAgentSlug,
+  resolveDefaultAgentSlug,
+  resolveAgentConfig,
+  getDefaultAccountId,
+  resolveUserAccounts,
+  fingerprintSessionKey,
+  registerSession,
+  validateSession,
+  getAccountIdForSession,
+  getUserIdForSession,
+  getUserNameForSession,
+  getRoleForSession,
+  getConversationIdForSession,
+  setConversationIdForSession,
+  setWantsPriorConversation,
+  unregisterSession,
+  getSessionKeyByConversationId,
+  findMissingPlugins,
+  walkPremiumBundles,
+  autoDeliverPremiumPlugins,
+  reconcileEnabledPlugins,
+  emitMissingOnResolve,
+  getBundleMtimeIso,
+  appendStreamLogLine,
+  stripAttachmentMetaSuffix,
   agentLogStream,
   clearSessionHistory,
   compactSession,
   completeGrantSetup,
-  findMissingPlugins,
-  fingerprintSessionKey,
-  getAccountIdForSession,
   getAgentNameForSession,
-  getConversationIdForSession,
-  getDefaultAccountId,
   getGrantForSession,
   getGroupSlugForSession,
-  getRoleForSession,
-  getSessionMessages,
   getStreamLogHandle,
-  getUserIdForSession,
-  getUserNameForSession,
   getVisitorIdForSession,
-  hasStubAccountDir,
   invokeAgent,
   listAdminSessionsInProgress,
-  mintAdminSessionToken,
   registerGrantSession,
   registerResumedSession,
-  registerSession,
-  resolveAccount,
-  resolveAgentConfig,
-  resolveDefaultAgentSlug,
-  resolveUserAccounts,
   setAgentSessionId,
-  setConversationIdForSession,
   setGroupContextForSession,
-  setWantsPriorConversation,
+  getSessionMessages,
   sigtermFlushStreamLogs,
   streamLogPathFor,
-  unregisterSession,
-  validateAgentSlug,
-  validateSession,
   safeJson,
   requireAdminSession,
   tryCookieBridgeForConversation,