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

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/types/index.d.ts

@@ -2,7 +2,7 @@
  * Public Bakin plugin contract types.
  *
  * This module is intentionally self-contained. External plugins must be able
- * to typecheck against `@bakin/sdk/types` without resolving `@bakin/core`,
+ * to typecheck against `@makinbakin/sdk/types` without resolving `@bakin/core`,
  * Bakin source aliases, adapter packages, or another plugin's internals.
  */
 import type { ComponentType } from 'react';
@@ -40,6 +40,14 @@ export interface PluginEntryPoints {
     server: string;
     client?: string;
 }
+export interface SecretDeclaration {
+    /** Canonical environment variable name, for example `ANTHROPIC_API_KEY`. */
+    name: string;
+    /** Human-readable setup note. Never include a secret value here. */
+    description: string;
+    /** Missing required secrets should be reported by setup/health checks. Defaults to true. */
+    required: boolean;
+}
 export interface ApiRouteContribution {
     method: HttpMethod;
     /** Plugin-relative path. Exposed as `/api/plugins/{pluginId}{path}`. */
@@ -140,7 +148,7 @@ export interface PluginManifest {
     description: string;
     entry: PluginEntryPoints;
     contentFiles?: string[];
-    secrets?: string[];
+    secrets?: SecretDeclaration[];
     tests?: string;
     dependencies?: string[];
     permissions?: PluginPermission[];
@@ -182,6 +190,12 @@ export interface ActivityAPI {
     }): void;
     audit(event: string, agent: string, data?: Record<string, unknown>): void;
 }
+export interface PluginLogger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, errorOrData?: unknown, data?: Record<string, unknown>): void;
+    error(message: string, errorOrData?: unknown, data?: Record<string, unknown>): void;
+}
 export interface HookAPI {
     register(name: string, handler: (data: unknown) => unknown, metadata?: HookRegistrationMetadata): () => void;
     call<T>(name: string, data: T): Promise<T>;
@@ -248,9 +262,25 @@ export interface RuntimeChannel {
     capabilities: string[];
     metadata?: Record<string, unknown>;
 }
-export interface RuntimeMessageArgs {
+export type RuntimeMessageToolsMode = 'auto' | 'none';
+export interface RuntimeMessageToolPolicy {
+    /**
+     * Controls whether runtime-native tools are available for this agent turn.
+     * `none` disables tools. Omit or use `auto` for runtime/provider defaults.
+     */
+    toolsMode?: RuntimeMessageToolsMode;
+    /** Optional runtime-native tool allowlist for this turn. */
+    toolsAllow?: string[];
+    /** Optional runtime-native tool denylist for this turn. */
+    toolsDeny?: string[];
+}
+export interface RuntimeMessageArgs extends RuntimeMessageToolPolicy {
     agentId: string;
     content: string;
+    /**
+     * Adapter-neutral durable conversation key. Runtime adapters should map the
+     * same agentId + threadId pair to the same provider/runtime session.
+     */
     threadId?: string;
     metadata?: Record<string, unknown>;
 }
@@ -259,10 +289,22 @@ export interface RuntimeMessageResult {
     content?: string;
     metadata?: Record<string, unknown>;
 }
+export interface RuntimeToolActivity {
+    phase: 'call' | 'result';
+    callId?: string;
+    toolName: string;
+    status?: 'running' | 'completed' | 'failed' | string;
+    summary?: string;
+    inputPreview?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    exitCode?: number;
+    metadata?: Record<string, unknown>;
+}
 export interface RuntimeChatChunk {
     type: 'text' | 'tool' | 'status' | 'done' | 'error';
     content?: string;
-    data?: unknown;
+    data?: Record<string, unknown> | RuntimeToolActivity;
 }
 export interface CronJob {
     id: string;
@@ -385,10 +427,19 @@ export interface Task {
     workflowId?: string;
     scheduleJobId?: string;
     projectId?: string;
+    availableAt?: string;
+    dueAt?: string;
+    source?: TaskSource;
     order?: number;
     createdAt?: string;
     updatedAt?: string;
 }
+export interface TaskSource {
+    pluginId?: string;
+    entityType?: string;
+    entityId?: string;
+    purpose?: string;
+}
 export interface TaskColumns {
     backlog: Task[];
     inProgress: Task[];
@@ -414,6 +465,9 @@ export interface TaskCreateInput {
     workflowId?: string;
     projectId?: string;
     parentId?: string | null;
+    availableAt?: string;
+    dueAt?: string;
+    source?: TaskSource;
     skipWorkflowReason?: string;
 }
 export interface TaskUpdateInput {
@@ -429,6 +483,9 @@ export interface TaskUpdateInput {
     scheduleJobId?: string;
     projectId?: string;
     parentId?: string | null;
+    availableAt?: string | null;
+    dueAt?: string | null;
+    source?: TaskSource | null;
 }
 export interface TaskService {
     create(input: TaskCreateInput): Promise<Task>;
@@ -667,11 +724,39 @@ export interface HealthCheckResult {
     message: string;
     autoFixable: boolean;
 }
+export type HealthRepairSafety = 'safe' | 'manual' | 'destructive';
+export interface HealthRepairChange {
+    kind: 'file' | 'setting' | 'service' | 'runtime' | 'task' | 'other';
+    target: string;
+    action: 'create' | 'update' | 'delete' | 'install' | 'invoke';
+    description: string;
+}
+export interface HealthRepairPlanItem {
+    id: string;
+    checkId: string;
+    title: string;
+    reason: string;
+    safety: HealthRepairSafety;
+    requiresConfirmation: boolean;
+    changes: HealthRepairChange[];
+}
+export interface HealthRepairApplyResult {
+    id: string;
+    checkId: string;
+    status: 'applied' | 'skipped' | 'failed';
+    message: string;
+    changes: HealthRepairChange[];
+}
+export interface HealthRepairHandler {
+    plan(rows: HealthCheckResult[]): Promise<HealthRepairPlanItem[]>;
+    apply(items: HealthRepairPlanItem[]): Promise<HealthRepairApplyResult[]>;
+}
 export interface PluginHealthCheckInput {
     id: string;
     name: string;
     run: () => Promise<HealthCheckResult[]>;
     autoFix?: boolean;
+    repair?: HealthRepairHandler;
 }
 interface BaseSettingsField {
     key: string;
@@ -734,6 +819,7 @@ export interface PluginContext {
     getSettings<T = Record<string, unknown>>(): T;
     updateSettings(patch: Record<string, unknown>): void;
     activity: ActivityAPI;
+    log?: PluginLogger;
     hooks: HookAPI;
     search: SearchAPI;
 }

package/ui/index.d.ts

@@ -1,9 +1,9 @@
 /**
- * `@bakin/sdk/ui` — shadcn base UI primitives for plugin authors.
+ * `@makinbakin/sdk/ui` — shadcn base UI primitives for plugin authors.
  *
  * These are re-exports from Bakin's `src/components/ui/*`. At Bakin build time
  * they resolve to source. At plugin build time (Phase 3) the plugin author
- * marks `@bakin/sdk` and `@bakin/sdk/ui` as externals so the plugin bundle
+ * marks `@makinbakin/sdk` and `@makinbakin/sdk/ui` as externals so the plugin bundle
  * doesn't duplicate these. At runtime the browser's import map resolves the
  * externals to Bakin's bundled copy.
  */

package/utils/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@bakin/sdk/utils` — tiny utilities for plugin authors.
+ * `@makinbakin/sdk/utils` — tiny utilities for plugin authors.
  *
  * `cn(...)` is the Tailwind class merger every shadcn-flavored component
  * needs. The `format*` helpers are re-exported from `@bakin/core/format`
@@ -7,3 +7,8 @@
  */
 export { cn } from '../_internal/app/lib/utils';
 export { formatAge, formatSize, isStale } from '../_internal/core/format';
+export { brainstormActivityMessageFromCustom, runtimeChunkToBrainstormActivity, toBrainstormTimeline, } from '../_internal/app/components/integrated-brainstorm/activity';
+export { brainstormThreadId, normalizeBrainstormActivityForStorage, normalizeBrainstormActivityMessageForStorage, } from '../_internal/app/components/integrated-brainstorm/session';
+export type { BrainstormActivityInput, BrainstormTimelineActivityInput, BrainstormTimelineMessageInput, } from '../_internal/app/components/integrated-brainstorm/activity';
+export type { BrainstormActivityStorageInput, BrainstormActivityStorageRecord, } from '../_internal/app/components/integrated-brainstorm/session';
+export { readBrainstormSseResponse } from '../_internal/app/components/integrated-brainstorm/sse';