@makinbakin/sdk 0.0.0-bootstrap.0 → 0.0.1-rc.10

package/routing/index.js

@@ -13696,6 +13696,333 @@ var errorEnvelope = exports_external.object({
   error: exports_external.string(),
   issues: exports_external.array(exports_external.unknown()).optional()
 });
+
+// packages/core/src/logger.ts
+import { createWriteStream, existsSync, mkdirSync, renameSync, statSync } from "fs";
+import { join as join2 } from "path";
+
+// packages/core/src/content-dir.ts
+import { join } from "path";
+import { homedir } from "os";
+// packages/core/src/constants.ts
+var APP_SLUG = "bakin";
+
+// packages/core/src/content-dir.ts
+function bakinHomeDefault() {
+  return join(homedir(), `.${APP_SLUG}`);
+}
+var resolvedContentDir = null;
+function isTestEnv() {
+  return process.env.VITEST === "true" || !!process.env.VITEST;
+}
+function realBakinHome() {
+  const realHome = process.env.HOME || process.env.USERPROFILE || "";
+  if (!realHome)
+    return "";
+  return join(realHome, `.${APP_SLUG}`);
+}
+function assertSafeForTest(path) {
+  if (!isTestEnv())
+    return;
+  const real = realBakinHome();
+  if (real && path === real) {
+    throw new Error(`[bakin] getContentDir() resolved to the real Bakin home (${real}) ` + `during a test run. This would write test data to your production instance. ` + `Fix: mock src/core/content-dir in this test, or set BAKIN_HOME to a temp ` + `directory before importing any Bakin module. See CLAUDE.md \xA7 Testing Rules.`);
+  }
+}
+function getContentDir() {
+  if (resolvedContentDir)
+    return resolvedContentDir;
+  const resolved = resolveContentDirInner();
+  assertSafeForTest(resolved);
+  resolvedContentDir = resolved;
+  return resolvedContentDir;
+}
+function resolveContentDirInner() {
+  if (process.env.BAKIN_HOME)
+    return process.env.BAKIN_HOME;
+  return bakinHomeDefault();
+}
+function getBakinPaths() {
+  const home = getContentDir();
+  const assets = join(home, "assets");
+  return {
+    home,
+    memoryLog: join(home, "MEMORY-LOG.md"),
+    audit: join(home, "audit.jsonl"),
+    assets,
+    "assets.store": join(assets, "store"),
+    "assets.inbox": join(assets, "inbox"),
+    "assets.trash": join(assets, ".trash"),
+    agents: join(home, "agents"),
+    personas: join(home, "team", "personas"),
+    team: join(home, "team"),
+    heartbeats: join(home, "heartbeats"),
+    inbox: join(home, "inbox"),
+    tasks: join(home, "tasks"),
+    workflows: join(home, "workflows"),
+    settings: join(home, "settings.json"),
+    logs: join(home, "logs")
+  };
+}
+
+// packages/core/src/logger.ts
+var MAX_LOG_BYTES = 10 * 1024 * 1024;
+var LEVEL_RANK = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var COLOR_RESET = "\x1B[0m";
+var COLORS = {
+  dim: "\x1B[2m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  magenta: "\x1B[35m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m"
+};
+var fileStream = null;
+var fileTransportInitialized = false;
+var fileTransportDisabled = false;
+function fileTransportEnabled() {
+  if (fileTransportDisabled)
+    return false;
+  if (false)
+    ;
+  if (process.env.VITEST)
+    return false;
+  if (process.env.BAKIN_DISABLE_FILE_LOG === "1")
+    return false;
+  return true;
+}
+function ensureFileStream() {
+  if (fileTransportInitialized)
+    return fileStream;
+  fileTransportInitialized = true;
+  if (!fileTransportEnabled())
+    return null;
+  try {
+    const logsDir = getBakinPaths().logs;
+    if (!existsSync(logsDir))
+      mkdirSync(logsDir, { recursive: true });
+    const logPath = join2(logsDir, "server.log");
+    if (existsSync(logPath)) {
+      try {
+        const size = statSync(logPath).size;
+        if (size > MAX_LOG_BYTES) {
+          const rotated = join2(logsDir, "server.log.1");
+          renameSync(logPath, rotated);
+        }
+      } catch {}
+    }
+    fileStream = createWriteStream(logPath, { flags: "a" });
+    fileStream.on("error", () => {
+      fileTransportDisabled = true;
+      fileStream = null;
+    });
+  } catch {
+    fileTransportDisabled = true;
+    fileStream = null;
+  }
+  return fileStream;
+}
+function formatEntry(entry) {
+  const parts = [`[${entry.ts}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`];
+  if (entry.error)
+    parts.push(`  error: ${entry.error}`);
+  if (entry.data)
+    parts.push(`  data: ${JSON.stringify(entry.data)}`);
+  return parts.join(`
+`);
+}
+function consoleFormat() {
+  const configured = process.env.BAKIN_CONSOLE_FORMAT;
+  if (configured === "pretty" || configured === "verbose" || configured === "plain" || configured === "silent") {
+    return configured;
+  }
+  return process.stdout.isTTY === true ? "pretty" : "plain";
+}
+function consoleMinLevel(format) {
+  const configured = process.env.BAKIN_LOG_LEVEL;
+  if (configured === "debug" || configured === "info" || configured === "warn" || configured === "error") {
+    return configured;
+  }
+  if (format === "verbose")
+    return "debug";
+  if (format === "silent")
+    return "error";
+  if (format === "pretty")
+    return "info";
+  return "debug";
+}
+function colorEnabled(format) {
+  if (format === "plain")
+    return false;
+  if (process.env.NO_COLOR || process.env.BAKIN_NO_COLOR === "1")
+    return false;
+  return process.stdout.isTTY === true;
+}
+function colorize(text, color, enabled) {
+  return enabled ? `${COLORS[color]}${text}${COLOR_RESET}` : text;
+}
+function sourceLabel(entry) {
+  const data = entry.data;
+  const explicitSource = typeof data?.source === "string" ? data.source : undefined;
+  const pluginId = typeof data?.pluginId === "string" ? data.pluginId : undefined;
+  if (explicitSource === "antfly")
+    return "antfly";
+  if (explicitSource === "dev")
+    return "dev";
+  if (explicitSource === "plugin" && pluginId)
+    return `plugin:${pluginId}`;
+  if (entry.module === "plugin-registry" && pluginId)
+    return `plugin:${pluginId}`;
+  if (entry.module.startsWith("api:"))
+    return "api";
+  return entry.module;
+}
+function sourceColor(source) {
+  if (source === "dev")
+    return "cyan";
+  if (source === "server")
+    return "blue";
+  if (source === "antfly")
+    return "magenta";
+  if (source.startsWith("plugin:"))
+    return "green";
+  if (source.includes("search"))
+    return "cyan";
+  if (source.includes("runtime"))
+    return "magenta";
+  return "dim";
+}
+function levelColor(level) {
+  if (level === "debug")
+    return "dim";
+  if (level === "warn")
+    return "yellow";
+  if (level === "error")
+    return "red";
+  return "blue";
+}
+function isImportantAntflyInfo(entry) {
+  return [
+    "Metadata API server is ready",
+    "Store HTTP server is ready",
+    "Swarm mode: all servers are ready",
+    "Termite's api server starting"
+  ].some((message) => entry.message.includes(message));
+}
+function suppressPrettyInfo(entry) {
+  if (entry.level !== "info")
+    return false;
+  if (entry.data?.source === "antfly")
+    return !isImportantAntflyInfo(entry);
+  if (entry.module === "plugin-registry") {
+    return entry.message === "plugin activated" || entry.message.startsWith("Auto-registered ") || entry.message.startsWith("Plugin activation order:");
+  }
+  return [
+    "search-registry",
+    "search-reconcile",
+    "search-cleanup",
+    "hot-reload-coordinator",
+    "mcporter",
+    "dispatch",
+    "watchdog",
+    "doctor",
+    "lifecycle"
+  ].includes(entry.module);
+}
+function shouldWriteConsole(entry, format) {
+  if (format === "silent")
+    return false;
+  const minLevel = consoleMinLevel(format);
+  if (LEVEL_RANK[entry.level] < LEVEL_RANK[minLevel])
+    return false;
+  if (format === "pretty" && suppressPrettyInfo(entry))
+    return false;
+  return true;
+}
+function formatPrettyEntry(entry, format) {
+  const colors = colorEnabled(format);
+  const time3 = new Date(entry.ts).toTimeString().slice(0, 8);
+  const level = entry.level.padEnd(5);
+  const source = sourceLabel(entry);
+  const label = source.padEnd(18);
+  const levelPart = colorize(level, levelColor(entry.level), colors);
+  const sourcePart = colorize(label, sourceColor(source), colors);
+  const messagePart = entry.level === "error" ? colorize(entry.message, "red", colors) : entry.message;
+  const parts = [`${colorize(time3, "dim", colors)}  ${levelPart}  ${sourcePart}  ${messagePart}`];
+  if (entry.error)
+    parts[0] += ` - ${entry.error}`;
+  if (format === "verbose" && entry.data) {
+    parts.push(`  data: ${JSON.stringify(entry.data)}`);
+  }
+  return parts.join(`
+`);
+}
+function formatConsoleEntry(entry) {
+  const format = consoleFormat();
+  if (format === "plain")
+    return formatEntry(entry);
+  if (format === "silent")
+    return "";
+  return formatPrettyEntry(entry, format);
+}
+function writeToFile(entry) {
+  const stream = ensureFileStream();
+  if (!stream)
+    return;
+  try {
+    stream.write(JSON.stringify(entry) + `
+`);
+  } catch {
+    fileTransportDisabled = true;
+    fileStream = null;
+  }
+}
+function createLogger(module) {
+  function log(level, message, errorOrData, data) {
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      module,
+      message
+    };
+    if (errorOrData instanceof Error) {
+      entry.error = errorOrData.message;
+      entry.data = data ? { ...data, stack: errorOrData.stack } : { stack: errorOrData.stack };
+    } else if (typeof errorOrData === "string") {
+      entry.error = errorOrData;
+      entry.data = data;
+    } else if (errorOrData && typeof errorOrData === "object") {
+      entry.data = errorOrData;
+    }
+    const format = consoleFormat();
+    if (shouldWriteConsole(entry, format)) {
+      const formatted = formatConsoleEntry(entry);
+      if (level === "error") {
+        console.error(formatted);
+      } else if (level === "warn") {
+        console.warn(formatted);
+      } else {
+        console.log(formatted);
+      }
+    }
+    writeToFile(entry);
+  }
+  return {
+    debug: (message, data) => log("debug", message, data),
+    info: (message, data) => log("info", message, data),
+    warn: (message, errorOrData, data) => log("warn", message, errorOrData, data),
+    error: (message, errorOrData, data) => log("error", message, errorOrData, data)
+  };
+}
+
+// packages/core/src/routing/dispatcher.ts
+var log = createLogger("dispatcher");
 // packages/core/src/routing/search-route.ts
 var searchQuery = exports_external.object({
   q: exports_external.string().min(1),

package/slots/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@bakin/sdk/slots` — client-side slot registry + `<Slot>` primitive.
+ * `@makinbakin/sdk/slots` — client-side slot registry + `<Slot>` primitive.
  *
  * The slot system lets a plugin render components contributed by other
  * plugins at a named extension point. Today it's used for:

package/slots/index.js

@@ -20,15 +20,34 @@ function getRegistry() {
       cleanupByPlugin: new Map,
       navItemsSnapshot: [],
       version: 0,
-      listeners: new Set
+      listeners: new Set,
+      badgesByPlugin: new Map,
+      badgesSnapshot: new Map,
+      badgeListeners: new Set
     };
   }
   const registry = g.__bakinClientRegistry;
   if (!Array.isArray(registry.navItemsSnapshot)) {
     registry.navItemsSnapshot = buildNavItemsSnapshot(registry);
   }
+  if (!registry.badgesByPlugin)
+    registry.badgesByPlugin = new Map;
+  if (!registry.badgesSnapshot)
+    registry.badgesSnapshot = buildBadgesSnapshot(registry);
+  if (!registry.badgeListeners)
+    registry.badgeListeners = new Set;
   return registry;
 }
+function buildBadgesSnapshot(registry) {
+  const snapshot = new Map;
+  for (const byNavItemId of registry.badgesByPlugin.values()) {
+    for (const [navItemId, badge] of byNavItemId) {
+      if (!snapshot.has(navItemId))
+        snapshot.set(navItemId, badge);
+    }
+  }
+  return snapshot;
+}
 function getRegistryVersion() {
   return getRegistry().version;
 }