@makinbakin/sdk 0.0.1-rc.20 → 0.0.1-rc.21

package/routing/index.js

@@ -14,151 +14,6 @@ var __export = (target, all) => {
     });
 };
 
-// packages/core/src/routing/define.ts
-function defineRoute(route) {
-  return route;
-}
-function defineCoreRoute(route) {
-  return route;
-}
-function definePlugin(plugin) {
-  return plugin;
-}
-// packages/core/src/routing/operation-id.ts
-function operationIdFor(scope, method, path) {
-  return `${scope}.${method.toLowerCase()}.${slugifyPath(path)}`;
-}
-function slugifyPath(path) {
-  const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed === "")
-    return "root";
-  const segments = trimmed.split("/").map((seg) => {
-    if (seg.startsWith(":"))
-      return camelToKebab(seg.slice(1));
-    if (seg.startsWith("{") && seg.endsWith("}"))
-      return camelToKebab(seg.slice(1, -1));
-    return camelToKebab(seg);
-  }).filter(Boolean);
-  return segments.join("-");
-}
-function camelToKebab(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-// packages/core/src/routing/registry.ts
-function parseSegments(path) {
-  return path.split("/").filter(Boolean).map((seg) => {
-    if (seg === "*" || seg.startsWith("..."))
-      return { kind: "wildcard" };
-    if (seg.startsWith(":"))
-      return { kind: "param", name: seg.slice(1) };
-    if (seg.startsWith("{") && seg.endsWith("}")) {
-      return { kind: "param", name: seg.slice(1, -1) };
-    }
-    return { kind: "literal", value: seg };
-  });
-}
-function specificityScore(segments) {
-  let score = 0;
-  for (const seg of segments) {
-    if (seg.kind === "literal")
-      score += 2;
-    else if (seg.kind === "param")
-      score += 1;
-  }
-  return score;
-}
-function matchSegments(pathSegments, routeSegments) {
-  const lastIsWildcard = routeSegments.length > 0 && routeSegments[routeSegments.length - 1].kind === "wildcard";
-  if (!lastIsWildcard && pathSegments.length !== routeSegments.length)
-    return null;
-  if (lastIsWildcard && pathSegments.length < routeSegments.length - 1)
-    return null;
-  const params = {};
-  for (let i = 0;i < routeSegments.length; i++) {
-    const rseg = routeSegments[i];
-    if (rseg.kind === "wildcard")
-      return params;
-    const pseg = pathSegments[i];
-    if (rseg.kind === "literal") {
-      if (rseg.value !== pseg)
-        return null;
-    } else {
-      params[rseg.name] = pseg;
-    }
-  }
-  return params;
-}
-
-class RouteRegistry {
-  byMethod = new Map;
-  operationIds = new Set;
-  fullPaths = new Set;
-  register(input) {
-    const { route } = input;
-    const pluginId = input.scope === "plugin" ? input.pluginId : null;
-    const fullPath = pluginId !== null ? `/api/plugins/${pluginId}${route.path}` : route.path;
-    const operationId = route.operationId ?? operationIdFor(pluginId ?? "core", route.method, route.path);
-    const dupKey = `${route.method} ${fullPath}`;
-    if (this.fullPaths.has(dupKey)) {
-      throw new Error(`duplicate route registration: ${dupKey}`);
-    }
-    if (this.operationIds.has(operationId)) {
-      throw new Error(`duplicate operationId: ${operationId} (route: ${dupKey})`);
-    }
-    this.fullPaths.add(dupKey);
-    this.operationIds.add(operationId);
-    const segments = parseSegments(fullPath);
-    const indexed = {
-      registered: {
-        route,
-        scope: pluginId ?? "core",
-        fullPath,
-        operationId
-      },
-      segments,
-      score: specificityScore(segments)
-    };
-    let bucket = this.byMethod.get(route.method);
-    if (!bucket) {
-      bucket = [];
-      this.byMethod.set(route.method, bucket);
-    }
-    bucket.push(indexed);
-    bucket.sort((a, b) => b.score - a.score);
-    return indexed.registered;
-  }
-  match(method, path) {
-    const bucket = this.byMethod.get(method);
-    if (!bucket)
-      return null;
-    const normalized = path.replace(/\/+$/, "") || "/";
-    const pathSegments = normalized.split("/").filter(Boolean);
-    for (const indexed of bucket) {
-      const params = matchSegments(pathSegments, indexed.segments);
-      if (params !== null) {
-        return {
-          ...indexed.registered,
-          params
-        };
-      }
-    }
-    return null;
-  }
-  all() {
-    const out = [];
-    for (const bucket of this.byMethod.values()) {
-      for (const entry of bucket)
-        out.push(entry.registered);
-    }
-    return out;
-  }
-  clear() {
-    this.byMethod.clear();
-    this.operationIds.clear();
-    this.fullPaths.clear();
-  }
-}
 // node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -13760,9 +13615,13 @@ function getBakinPaths() {
     inbox: join(home, "inbox"),
     tasks: join(home, "tasks"),
     workflows: join(home, "workflows"),
+    brands: join(home, "brands"),
+    chat: join(home, "chat"),
     settings: join(home, "settings.json"),
     logs: join(home, "logs"),
-    db: join(home, "bakin.db")
+    antfly: join(home, "antfly"),
+    db: join(home, "bakin.db"),
+    bin: join(home, "bin")
   };
 }
 
@@ -13934,7 +13793,6 @@ function suppressPrettyInfo(entry) {
     "search-cleanup",
     "search-startup",
     "hot-reload-coordinator",
-    "mcporter",
     "dispatch",
     "dispatch-state",
     "dispatch-turns",
@@ -14035,6 +13893,176 @@ function createLogger(module) {
 
 // packages/core/src/routing/dispatcher.ts
 var log = createLogger("dispatcher");
+var VALID_BODY_CONTENT_TYPES = ["application/json", "multipart/form-data", "*/*", "none"];
+function assertValidBodySpec(body, label) {
+  if (body === undefined || body === null)
+    return;
+  if (isZodType(body))
+    return;
+  if (typeof body !== "object" || !("contentType" in body)) {
+    throw new Error(`route ${label}: body spec must be a zod schema or declare a contentType (got ${JSON.stringify(body)})`);
+  }
+  const ct = body.contentType;
+  if (!VALID_BODY_CONTENT_TYPES.includes(ct)) {
+    throw new Error(`route ${label}: unknown body contentType '${String(ct)}' \u2014 valid values: ${VALID_BODY_CONTENT_TYPES.join(", ")}`);
+  }
+  if (ct === "application/json" && !isZodType(body.schema)) {
+    throw new Error(`route ${label}: contentType 'application/json' requires a zod schema`);
+  }
+}
+function isZodType(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  return value instanceof exports_external.ZodType || typeof value._zod === "object" && value._zod !== null;
+}
+
+// packages/core/src/routing/define.ts
+function defineRoute(route) {
+  assertValidBodySpec(route.body, `${route.method} ${route.path}`);
+  return route;
+}
+function defineCoreRoute(route) {
+  assertValidBodySpec(route.body, `${route.method} ${route.path}`);
+  return route;
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+// packages/core/src/routing/operation-id.ts
+function operationIdFor(scope, method, path) {
+  return `${scope}.${method.toLowerCase()}.${slugifyPath(path)}`;
+}
+function slugifyPath(path) {
+  const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (trimmed === "")
+    return "root";
+  const segments = trimmed.split("/").map((seg) => {
+    if (seg.startsWith(":"))
+      return camelToKebab(seg.slice(1));
+    if (seg.startsWith("{") && seg.endsWith("}"))
+      return camelToKebab(seg.slice(1, -1));
+    return camelToKebab(seg);
+  }).filter(Boolean);
+  return segments.join("-");
+}
+function camelToKebab(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+
+// packages/core/src/routing/registry.ts
+function parseSegments(path) {
+  return path.split("/").filter(Boolean).map((seg) => {
+    if (seg === "*" || seg.startsWith("..."))
+      return { kind: "wildcard" };
+    if (seg.startsWith(":"))
+      return { kind: "param", name: seg.slice(1) };
+    if (seg.startsWith("{") && seg.endsWith("}")) {
+      return { kind: "param", name: seg.slice(1, -1) };
+    }
+    return { kind: "literal", value: seg };
+  });
+}
+function specificityScore(segments) {
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.kind === "literal")
+      score += 2;
+    else if (seg.kind === "param")
+      score += 1;
+  }
+  return score;
+}
+function matchSegments(pathSegments, routeSegments) {
+  const lastIsWildcard = routeSegments.length > 0 && routeSegments[routeSegments.length - 1].kind === "wildcard";
+  if (!lastIsWildcard && pathSegments.length !== routeSegments.length)
+    return null;
+  if (lastIsWildcard && pathSegments.length < routeSegments.length - 1)
+    return null;
+  const params = {};
+  for (let i = 0;i < routeSegments.length; i++) {
+    const rseg = routeSegments[i];
+    if (rseg.kind === "wildcard")
+      return params;
+    const pseg = pathSegments[i];
+    if (rseg.kind === "literal") {
+      if (rseg.value !== pseg)
+        return null;
+    } else {
+      params[rseg.name] = pseg;
+    }
+  }
+  return params;
+}
+
+class RouteRegistry {
+  byMethod = new Map;
+  operationIds = new Set;
+  fullPaths = new Set;
+  register(input) {
+    const { route } = input;
+    const pluginId = input.scope === "plugin" ? input.pluginId : null;
+    const fullPath = pluginId !== null ? `/api/plugins/${pluginId}${route.path}` : route.path;
+    const operationId = route.operationId ?? operationIdFor(pluginId ?? "core", route.method, route.path);
+    const dupKey = `${route.method} ${fullPath}`;
+    if (this.fullPaths.has(dupKey)) {
+      throw new Error(`duplicate route registration: ${dupKey}`);
+    }
+    if (this.operationIds.has(operationId)) {
+      throw new Error(`duplicate operationId: ${operationId} (route: ${dupKey})`);
+    }
+    this.fullPaths.add(dupKey);
+    this.operationIds.add(operationId);
+    const segments = parseSegments(fullPath);
+    const indexed = {
+      registered: {
+        route,
+        scope: pluginId ?? "core",
+        fullPath,
+        operationId
+      },
+      segments,
+      score: specificityScore(segments)
+    };
+    let bucket = this.byMethod.get(route.method);
+    if (!bucket) {
+      bucket = [];
+      this.byMethod.set(route.method, bucket);
+    }
+    bucket.push(indexed);
+    bucket.sort((a, b) => b.score - a.score);
+    return indexed.registered;
+  }
+  match(method, path) {
+    const bucket = this.byMethod.get(method);
+    if (!bucket)
+      return null;
+    const normalized = path.replace(/\/+$/, "") || "/";
+    const pathSegments = normalized.split("/").filter(Boolean);
+    for (const indexed of bucket) {
+      const params = matchSegments(pathSegments, indexed.segments);
+      if (params !== null) {
+        return {
+          ...indexed.registered,
+          params
+        };
+      }
+    }
+    return null;
+  }
+  all() {
+    const out = [];
+    for (const bucket of this.byMethod.values()) {
+      for (const entry of bucket)
+        out.push(entry.registered);
+    }
+    return out;
+  }
+  clear() {
+    this.byMethod.clear();
+    this.operationIds.clear();
+    this.fullPaths.clear();
+  }
+}
 // packages/core/src/routing/search-route.ts
 var searchQuery = exports_external.object({
   q: exports_external.string().min(1),

package/slots/index.js

@@ -66,7 +66,10 @@ function getRegistry2() {
       listeners: new Set,
       badgesByPlugin: new Map,
       badgesSnapshot: new Map,
-      badgeListeners: new Set
+      badgeListeners: new Set,
+      hitRenderersByPlugin: new Map,
+      hitRenderersSnapshot: new Map,
+      hitRendererListeners: new Set
     };
   }
   const registry = g.__bakinClientRegistry;
@@ -81,8 +84,24 @@ function getRegistry2() {
     registry.badgesSnapshot = buildBadgesSnapshot(registry);
   if (!registry.badgeListeners)
     registry.badgeListeners = new Set;
+  if (!registry.hitRenderersByPlugin)
+    registry.hitRenderersByPlugin = new Map;
+  if (!registry.hitRenderersSnapshot)
+    registry.hitRenderersSnapshot = buildHitRenderersSnapshot(registry);
+  if (!registry.hitRendererListeners)
+    registry.hitRendererListeners = new Set;
   return registry;
 }
+function buildHitRenderersSnapshot(registry) {
+  const snapshot = new Map;
+  for (const byType of registry.hitRenderersByPlugin.values()) {
+    for (const [type, renderer] of byType) {
+      if (!snapshot.has(type))
+        snapshot.set(type, renderer);
+    }
+  }
+  return snapshot;
+}
 function buildBadgesSnapshot(registry) {
   const snapshot = new Map;
   for (const byNavItemId of registry.badgesByPlugin.values()) {

package/testing/index.d.ts

@@ -0,0 +1,122 @@
+import type { BakinPlugin, ExecToolDefinition, ExecToolResult, HealthCheckRegistrationInput, HealthRepairActionDefinition, NavItem, PluginContext, PluginNodeTypeInput, PluginNotificationChannelInput, PluginToolContext, SearchResponse, SearchResult, SkillDefinition, UISlotRegistration, WorkflowDefinitionInput } from '../types/index';
+import type { APIRoute } from '../routing/index';
+/** One captured `ctx.log` line. */
+export interface CapturedLog {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: unknown;
+}
+/** One captured `ctx.activity.log` / `ctx.activity.audit` call. */
+export interface CapturedActivity {
+    kind: 'log' | 'audit';
+    agent: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * The harness returned by {@link createTestContext} / {@link activatePlugin}.
+ * Everything the plugin registered is captured on plain arrays so tests can
+ * assert on it directly.
+ */
+export interface PluginTestContext {
+    /** The isolated context — pass to `callRoute`, or to the plugin directly. */
+    ctx: PluginContext;
+    /** All routes: declarative `plugin.routes` + the auto-wired search route. */
+    routes: APIRoute[];
+    /** Exec tools registered via `ctx.registerExecTool`. */
+    execTools: ExecToolDefinition[];
+    /** Nav items registered via `ctx.registerNav`. */
+    navItems: NavItem[];
+    /** Slot registrations via `ctx.registerSlot`. */
+    slots: UISlotRegistration[];
+    /** Workflows registered via `ctx.registerWorkflow`. */
+    workflows: WorkflowDefinitionInput[];
+    /** Node types registered via `ctx.registerNodeType`. */
+    nodeTypes: PluginNodeTypeInput<unknown>[];
+    /** Notification channels registered via `ctx.registerNotificationChannel`. */
+    notificationChannels: PluginNotificationChannelInput[];
+    /** Health checks registered via `ctx.registerHealthCheck`. */
+    healthChecks: HealthCheckRegistrationInput[];
+    /** Repair actions registered via `ctx.registerHealthRepairAction`. */
+    healthRepairActions: HealthRepairActionDefinition[];
+    /** Runtime skills registered via `ctx.registerSkill`. */
+    skills: SkillDefinition[];
+    /** File-watch patterns passed to `ctx.watchFiles`. */
+    watchedPatterns: string[];
+    /** Everything logged through `ctx.log`. */
+    logs: CapturedLog[];
+    /** Everything sent to `ctx.activity`. */
+    activity: CapturedActivity[];
+    /** Absolute path of the temp directory backing `ctx.storage`. */
+    dir: string;
+    /**
+     * Seed `ctx.search.query()` responses. All subsequent queries return these
+     * results until re-seeded.
+     */
+    seedSearchResults(results: SearchResult[], aggregations?: SearchResponse['aggregations']): void;
+    /** Build the `PluginToolContext` an exec tool receives as its third arg. */
+    toolContext(): PluginToolContext;
+    /** Delete the temp directory. Call from `afterAll`. Safe to call twice. */
+    dispose(): void;
+}
+export interface CreateTestContextOptions {
+    /** Initial `ctx.getSettings()` value. `ctx.updateSettings` patches it. */
+    settings?: Record<string, unknown>;
+    /**
+     * Use this directory instead of a fresh temp dir. The harness will NOT
+     * delete a caller-provided directory on `dispose()`.
+     */
+    dir?: string;
+}
+/**
+ * Create an isolated `PluginContext` for `pluginId`.
+ *
+ * Storage is a real filesystem adapter rooted at a fresh temp directory;
+ * events are a real in-process bus; hooks are a local registry (the plugin
+ * can invoke its own hooks); runtime/tasks are the SDK mock implementations;
+ * search is seedable via `seedSearchResults`. Registration calls are
+ * captured, never applied to any global registry.
+ */
+export declare function createTestContext(pluginId: string, options?: CreateTestContextOptions): PluginTestContext;
+/**
+ * Activate a plugin against a fresh test context. Declarative `plugin.routes`
+ * are collected first (as the host does), then `activate(ctx)` runs and its
+ * registrations land on the same arrays.
+ */
+export declare function activatePlugin(plugin: BakinPlugin, options?: CreateTestContextOptions): Promise<PluginTestContext>;
+/** Find a route by method and declared path (`'GET', '/items/:id'`). */
+export declare function findRoute(routes: APIRoute[], method: string, path: string): APIRoute | undefined;
+/** Find an exec tool by name. */
+export declare function findTool(tools: ExecToolDefinition[], name: string): ExecToolDefinition | undefined;
+/** Build a `Request` the way the host's router would. */
+export declare function makeRequest(path: string, opts?: {
+    method?: string;
+    body?: unknown;
+    searchParams?: Record<string, string>;
+}): Request;
+/**
+ * Call a route handler and return `{ status, body, response }`.
+ *
+ * Routes that declare typed contracts (`params`/`query`/`body`/`responses`)
+ * dispatch through the same router the host uses, so schema validation and
+ * the `(req, ctx, parsed)` handler signature behave exactly as in
+ * production. Path params resolve from `opts.path` (`'/abc-1/move'` binds
+ * `:taskId` for a route at `'/:taskId/move'`) or from `opts.searchParams`
+ * entries matching placeholder names.
+ */
+export declare function callRoute(route: APIRoute, ctx: PluginContext, opts?: {
+    path?: string;
+    body?: unknown;
+    searchParams?: Record<string, string>;
+    rawResponse?: boolean;
+}): Promise<{
+    status: number;
+    body: Record<string, unknown>;
+    response: Response;
+}>;
+/**
+ * Call an exec tool handler. Pass `toolCtx` (from `harness.toolContext()`)
+ * when the tool uses its third argument — scaffold-style tools that persist
+ * via `toolCtx.storage` need it.
+ */
+export declare function callTool(tool: ExecToolDefinition, params: Record<string, unknown>, agent?: string, toolCtx?: PluginToolContext): Promise<ExecToolResult>;