@babyclaw/gateway 0.0.0 → 0.2.0

package/dist/index.js

@@ -5,7 +5,8 @@ var __export = (target, all) => {
 };
 
 // src/runtime.ts
-import { resolve as resolve5 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { getBundledSkillsDir } from "@babyclaw/skills";
 
 // src/ai/agent.ts
 import {
@@ -280,37 +281,84 @@ var SUPPORTED_PROVIDERS = [
   {
     id: "anthropic",
     displayName: "Anthropic",
-    exampleModels: ["claude-sonnet-4-20250514", "claude-opus-4-6", "claude-haiku-4-5"]
+    exampleModels: [
+      "claude-sonnet-4-20250514",
+      "claude-opus-4-6",
+      "claude-haiku-4-5",
+      "claude-4.5-sonnet",
+      "claude-3.5-sonnet-20241022",
+      "claude-3.5-haiku-20241022"
+    ]
   },
   {
     id: "openai",
     displayName: "OpenAI",
-    exampleModels: ["gpt-4o", "gpt-4o-mini", "o3-mini"]
+    exampleModels: [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "gpt-4.1",
+      "gpt-4.1-mini",
+      "gpt-4.1-nano",
+      "o3",
+      "o3-mini",
+      "o4-mini"
+    ]
   },
   {
     id: "google",
     displayName: "Google Generative AI",
-    exampleModels: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"]
+    exampleModels: [
+      "gemini-2.5-pro",
+      "gemini-2.5-flash",
+      "gemini-2.0-flash",
+      "gemini-2.0-flash-lite"
+    ]
   },
   {
     id: "mistral",
     displayName: "Mistral",
-    exampleModels: ["mistral-large-latest", "mistral-small-latest"]
+    exampleModels: [
+      "mistral-large-latest",
+      "mistral-medium-latest",
+      "mistral-small-latest",
+      "codestral-latest",
+      "pixtral-large-latest"
+    ]
   },
   {
     id: "xai",
     displayName: "xAI",
-    exampleModels: ["grok-3", "grok-3-mini"]
+    exampleModels: ["grok-3", "grok-3-fast", "grok-3-mini", "grok-3-mini-fast"]
   },
   {
     id: "openrouter",
     displayName: "OpenRouter",
-    exampleModels: ["anthropic/claude-sonnet-4", "openai/gpt-4o", "google/gemini-2.5-pro"]
+    exampleModels: [
+      "anthropic/claude-sonnet-4",
+      "anthropic/claude-opus-4",
+      "anthropic/claude-4.5-sonnet",
+      "openai/gpt-4o",
+      "openai/gpt-4.1",
+      "openai/o3",
+      "openai/o4-mini",
+      "google/gemini-2.5-pro",
+      "google/gemini-2.5-flash",
+      "deepseek/deepseek-r1",
+      "deepseek/deepseek-chat-v3",
+      "meta-llama/llama-4-maverick",
+      "meta-llama/llama-4-scout"
+    ]
   },
   {
     id: "gateway",
     displayName: "Vercel AI Gateway",
-    exampleModels: ["anthropic/claude-sonnet-4-20250514", "openai/gpt-4o"]
+    exampleModels: [
+      "anthropic/claude-sonnet-4-20250514",
+      "anthropic/claude-opus-4-6",
+      "openai/gpt-4o",
+      "openai/gpt-4.1",
+      "google/gemini-2.5-pro"
+    ]
   }
 ];
 var PROVIDER_FACTORY_MAP = {
@@ -1995,9 +2043,26 @@ import { z } from "zod";
 // src/utils/path.ts
 import { resolve, sep } from "path";
 import { stat } from "fs/promises";
+var BUNDLED_SKILLS_PREFIX = "bundled-skills/";
 function normalizeSeparators({ path }) {
   return path.replaceAll("\\", "/");
 }
+function resolveBundledSkillPath({
+  bundledSkillsDir,
+  requestedPath
+}) {
+  const relative3 = requestedPath.slice(BUNDLED_SKILLS_PREFIX.length);
+  const normalized = normalizeSeparators({ path: relative3 }).trim();
+  if (normalized.length === 0) {
+    throw new Error("Path is required");
+  }
+  const absoluteRoot = resolve(bundledSkillsDir);
+  const absoluteTarget = resolve(absoluteRoot, normalized);
+  if (!isSubPath({ parent: absoluteRoot, child: absoluteTarget })) {
+    throw new Error("Path escapes bundled skills root");
+  }
+  return absoluteTarget;
+}
 function resolveWorkspacePath({
   workspaceRoot,
   requestedPath
@@ -3754,10 +3819,25 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_READ_FAILED",
         input: { path, format },
         action: async () => {
-          const absolutePath = resolveWorkspacePath({
-            workspaceRoot: context.workspaceRoot,
-            requestedPath: path
-          });
+          const isBundled = path.startsWith(BUNDLED_SKILLS_PREFIX);
+          let absolutePath;
+          if (isBundled) {
+            if (!context.bundledSkillsDir) {
+              throw new ToolExecutionError({
+                code: "BUNDLED_SKILLS_UNAVAILABLE",
+                message: "Bundled skills directory is not configured"
+              });
+            }
+            absolutePath = resolveBundledSkillPath({
+              bundledSkillsDir: context.bundledSkillsDir,
+              requestedPath: path
+            });
+          } else {
+            absolutePath = resolveWorkspacePath({
+              workspaceRoot: context.workspaceRoot,
+              requestedPath: path
+            });
+          }
           const raw = await readFile6(absolutePath, "utf8");
           ensurePayloadWithinLimit({
             value: raw,
@@ -3815,6 +3895,12 @@ function createWorkspaceTools({ context }) {
           hasValue: value !== void 0
         },
         action: async () => {
+          if (path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be written to"
+            });
+          }
           const absolutePath = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: path
@@ -3954,6 +4040,12 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_DELETE_FAILED",
         input: { path, recursive },
         action: async () => {
+          if (path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be deleted"
+            });
+          }
           const absolutePath = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: path
@@ -3990,6 +4082,12 @@ function createWorkspaceTools({ context }) {
         defaultCode: "WORKSPACE_MOVE_FAILED",
         input: { from_path, to_path, overwrite },
         action: async () => {
+          if (from_path.startsWith(BUNDLED_SKILLS_PREFIX) || to_path.startsWith(BUNDLED_SKILLS_PREFIX)) {
+            throw new ToolExecutionError({
+              code: "BUNDLED_SKILLS_READONLY",
+              message: "Bundled skills are read-only and cannot be moved"
+            });
+          }
           const fromAbsolute = resolveWorkspacePath({
             workspaceRoot: context.workspaceRoot,
             requestedPath: from_path
@@ -4170,44 +4268,15 @@ function createUnifiedTools({
   };
 }
 
-// src/onboarding/personality.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join9 } from "path";
-function getPersonalityFilePaths({ workspacePath }) {
-  return {
-    identityPath: join9(workspacePath, "IDENTITY.md"),
-    soulPath: join9(workspacePath, "SOUL.md"),
-    userPath: join9(workspacePath, "USER.md")
-  };
-}
-async function readPersonalityFiles({
-  workspacePath
+// src/bundled-skills/index.ts
+import { listBundledSlugs, readBundledSkillContent, getBundledSkillInfo } from "@babyclaw/skills";
+
+// src/workspace/skills/types.ts
+function getSkillKey({
+  frontmatter,
+  slug
 }) {
-  const { identityPath, soulPath, userPath } = getPersonalityFilePaths({ workspacePath });
-  const [identity, soul, user] = await Promise.all([
-    readOptionalFile2({ path: identityPath }),
-    readOptionalFile2({ path: soulPath }),
-    readOptionalFile2({ path: userPath })
-  ]);
-  return {
-    identity,
-    soul,
-    user
-  };
-}
-function hasCompletePersonalityFiles(files) {
-  return typeof files.identity === "string" && files.identity.trim().length > 0 && typeof files.soul === "string" && files.soul.trim().length > 0 && typeof files.user === "string" && files.user.trim().length > 0;
-}
-async function readOptionalFile2({ path }) {
-  try {
-    return await readFile7(path, "utf8");
-  } catch (error) {
-    const maybeErrno = error;
-    if (maybeErrno.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
+  return frontmatter?.openclaw?.skillKey ?? frontmatter?.name ?? slug;
 }
 
 // src/workspace/skills/eligibility.ts
@@ -4217,54 +4286,84 @@ function getEligibleSkills({
   skillsConfig,
   fullConfig
 }) {
-  return skills.filter((skill) => shouldIncludeSkill({ skill, skillsConfig, fullConfig }));
+  return skills.filter((skill) => {
+    const { frontmatter, slug } = skill;
+    const entry = skillsConfig.entries[getSkillKey({ frontmatter, slug })];
+    if (entry?.enabled === false) return false;
+    return checkSkillEligibility({ frontmatter, skillsConfig, fullConfig }).eligible;
+  });
 }
-function shouldIncludeSkill({
-  skill,
+function checkSkillEligibility({
+  frontmatter,
   skillsConfig,
   fullConfig
 }) {
-  const { frontmatter } = skill;
+  if (frontmatter.disableModelInvocation) {
+    return { eligible: false, reason: "Model invocation disabled" };
+  }
   const openclaw = frontmatter.openclaw;
-  const skillKey = openclaw?.skillKey ?? frontmatter.name;
-  const entry = skillsConfig.entries[skillKey];
-  if (entry?.enabled === false) return false;
-  if (frontmatter.disableModelInvocation) return false;
   if (openclaw?.os && openclaw.os.length > 0) {
-    if (!openclaw.os.includes(process.platform)) return false;
+    if (!openclaw.os.includes(process.platform)) {
+      return {
+        eligible: false,
+        reason: `Requires OS: ${openclaw.os.join(", ")} (current: ${process.platform})`
+      };
+    }
+  }
+  if (openclaw?.always) {
+    return { eligible: true, reason: null };
   }
-  if (openclaw?.always) return true;
   const requires = openclaw?.requires;
-  if (!requires) return true;
+  if (!requires) {
+    return { eligible: true, reason: null };
+  }
   if (requires.bins && requires.bins.length > 0) {
-    if (!requires.bins.every((bin) => binaryExists({ name: bin }))) return false;
+    const missing = requires.bins.filter((bin) => !binaryExists({ name: bin }));
+    if (missing.length > 0) {
+      return { eligible: false, reason: `Missing binaries: ${missing.join(", ")}` };
+    }
   }
   if (requires.anyBins && requires.anyBins.length > 0) {
-    if (!requires.anyBins.some((bin) => binaryExists({ name: bin }))) return false;
+    if (!requires.anyBins.some((bin) => binaryExists({ name: bin }))) {
+      return {
+        eligible: false,
+        reason: `Requires at least one of: ${requires.anyBins.join(", ")}`
+      };
+    }
   }
   if (requires.env && requires.env.length > 0) {
+    const skillKey = openclaw?.skillKey ?? frontmatter.name;
+    const entry = skillsConfig.entries[skillKey];
     const primaryEnv = openclaw?.primaryEnv;
     const hasApiKeyInConfig = Boolean(entry?.apiKey);
     for (const envVar of requires.env) {
       if (process.env[envVar]) continue;
       if (primaryEnv === envVar && hasApiKeyInConfig) continue;
-      return false;
+      return { eligible: false, reason: `Missing environment variable: ${envVar}` };
     }
   }
   if (requires.config && requires.config.length > 0) {
     for (const configPath of requires.config) {
-      if (!getConfigValue({ config: fullConfig, path: configPath })) return false;
+      if (!getConfigValue({ config: fullConfig, path: configPath })) {
+        return { eligible: false, reason: `Missing config value: ${configPath}` };
+      }
     }
   }
-  return true;
+  return { eligible: true, reason: null };
 }
+var binaryExistsCache = /* @__PURE__ */ new Map();
 function binaryExists({ name }) {
+  const cached = binaryExistsCache.get(name);
+  if (cached !== void 0) return cached;
+  let exists;
   try {
     execFileSync("which", [name], { stdio: "ignore" });
-    return true;
+    exists = true;
   } catch {
-    return false;
+    exists = false;
   }
+  binaryExistsCache.set(name, exists);
+  return exists;
 }
 function getConfigValue({
   config,
@@ -4279,6 +4378,94 @@ function getConfigValue({
   return current;
 }
 
+// src/bundled-skills/index.ts
+function listBundledSkills({
+  skillsConfig,
+  fullConfig
+}) {
+  const slugs = listBundledSlugs();
+  return slugs.map((slug) => {
+    const content = readBundledSkillContent({ slug });
+    if (!content) {
+      return {
+        slug,
+        frontmatter: null,
+        enabled: false,
+        eligible: false,
+        ineligibilityReason: "Could not read SKILL.md"
+      };
+    }
+    const raw = parseFrontmatter({ content });
+    const frontmatter = raw ? buildFrontmatter({ raw }) : null;
+    const skillKey = getSkillKey({ frontmatter, slug });
+    const entry = skillsConfig.entries[skillKey];
+    const enabled = entry?.enabled === true;
+    const { eligible, reason } = frontmatter ? checkSkillEligibility({ frontmatter, skillsConfig, fullConfig }) : { eligible: false, reason: "Invalid frontmatter" };
+    return {
+      slug,
+      frontmatter,
+      enabled,
+      eligible,
+      ineligibilityReason: reason
+    };
+  });
+}
+function getEnabledBundledSkills({
+  skillsConfig,
+  fullConfig
+}) {
+  const all = listBundledSkills({ skillsConfig, fullConfig });
+  return all.filter((s) => s.enabled && s.eligible && s.frontmatter).map((s) => ({
+    frontmatter: s.frontmatter,
+    slug: s.slug,
+    relativePath: `bundled-skills/${s.slug}/SKILL.md`
+  }));
+}
+function getBundledSkillPath({ slug }) {
+  const info = getBundledSkillInfo({ slug });
+  return info?.skillDir ?? null;
+}
+
+// src/onboarding/personality.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join9 } from "path";
+function getPersonalityFilePaths({ workspacePath }) {
+  return {
+    identityPath: join9(workspacePath, "IDENTITY.md"),
+    soulPath: join9(workspacePath, "SOUL.md"),
+    userPath: join9(workspacePath, "USER.md")
+  };
+}
+async function readPersonalityFiles({
+  workspacePath
+}) {
+  const { identityPath, soulPath, userPath } = getPersonalityFilePaths({ workspacePath });
+  const [identity, soul, user] = await Promise.all([
+    readOptionalFile2({ path: identityPath }),
+    readOptionalFile2({ path: soulPath }),
+    readOptionalFile2({ path: userPath })
+  ]);
+  return {
+    identity,
+    soul,
+    user
+  };
+}
+function hasCompletePersonalityFiles(files) {
+  return typeof files.identity === "string" && files.identity.trim().length > 0 && typeof files.soul === "string" && files.soul.trim().length > 0 && typeof files.user === "string" && files.user.trim().length > 0;
+}
+async function readOptionalFile2({ path }) {
+  try {
+    return await readFile7(path, "utf8");
+  } catch (error) {
+    const maybeErrno = error;
+    if (maybeErrno.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
 // src/agent/context.ts
 async function loadAgentContext({
   workspacePath,
@@ -4291,7 +4478,11 @@ async function loadAgentContext({
     readWorkspaceGuide({ workspacePath }),
     scanWorkspaceSkills({ workspacePath })
   ]);
-  const skills = getEligibleSkills({ skills: allSkills, skillsConfig, fullConfig });
+  const workspaceSkills = getEligibleSkills({ skills: allSkills, skillsConfig, fullConfig });
+  const bundledSkills = getEnabledBundledSkills({ skillsConfig, fullConfig });
+  const workspaceSlugs = new Set(workspaceSkills.map((s) => s.slug));
+  const dedupedBundled = bundledSkills.filter((s) => !workspaceSlugs.has(s.slug));
+  const skills = [...workspaceSkills, ...dedupedBundled];
   const personalityFiles = hasCompletePersonalityFiles(rawPersonalityFiles) ? rawPersonalityFiles : void 0;
   return { personalityFiles, toolNotesContent, agentsContent, skills };
 }
@@ -4472,6 +4663,7 @@ var AgentTurnOrchestrator = class {
     if (abortSignal.aborted) return;
     const {
       workspacePath,
+      bundledSkillsDir,
       aiAgent,
       sessionManager,
       schedulerService,
@@ -4571,6 +4763,7 @@ ${description}`;
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: event.platform,
         chatId: event.chatId,
@@ -5885,11 +6078,11 @@ var ChatRegistry = class {
 
 // src/config/loader.ts
 import { access, mkdir as mkdir5, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 
 // src/config/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
+import { dirname as dirname5, join as join11, resolve as resolve4, isAbsolute } from "path";
 var CONFIG_PATH_ENV_VAR = "BABYCLAW_CONFIG_PATH";
 function getDefaultConfigPath() {
   return join11(homedir2(), ".babyclaw", "babyclaw.json");
@@ -5901,6 +6094,19 @@ function getConfigPath() {
   }
   return getDefaultConfigPath();
 }
+function getConfigDir() {
+  return dirname5(getConfigPath());
+}
+var DEFAULT_WORKSPACE_ROOT = "~/babyclaw";
+function resolveWorkspaceRoot({ configRoot }) {
+  if (configRoot === "~" || configRoot.startsWith("~/")) {
+    return join11(homedir2(), configRoot.slice(2));
+  }
+  if (isAbsolute(configRoot)) {
+    return configRoot;
+  }
+  return resolve4(getConfigDir(), configRoot);
+}
 
 // src/config/schema.ts
 import { z as z11 } from "zod";
@@ -6054,9 +6260,9 @@ var babyclawConfigSchema = z11.object({
     timezone: "UTC"
   }),
   workspace: z11.object({
-    root: z11.string().min(1).default(".")
+    root: z11.string().min(1).default("~/babyclaw")
   }).strict().default({
-    root: "."
+    root: "~/babyclaw"
   }),
   session: z11.object({
     maxMessagesPerSession: z11.number().int().positive().default(120),
@@ -6116,7 +6322,7 @@ var DEFAULT_CONFIG_TEMPLATE = {
     timezone: "UTC"
   },
   workspace: {
-    root: "."
+    root: "~/babyclaw"
   },
   session: {
     maxMessagesPerSession: 120,
@@ -6191,7 +6397,7 @@ async function loadConfigRaw() {
 }
 async function writeConfig({ config }) {
   const configPath = getConfigPath();
-  await mkdir5(dirname5(configPath), { recursive: true });
+  await mkdir5(dirname6(configPath), { recursive: true });
   await writeFile5(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 async function ensureConfigFileExists({ configPath }) {
@@ -6202,7 +6408,7 @@ async function ensureConfigFileExists({ configPath }) {
     if (error.code !== "ENOENT") {
       throw error;
     }
-    await mkdir5(dirname5(configPath), { recursive: true });
+    await mkdir5(dirname6(configPath), { recursive: true });
     await writeFile5(configPath, getDefaultConfigTemplate(), "utf8");
     getLogger().warn({ configPath }, "Created config file. Fill required secrets and restart.");
   }
@@ -6374,6 +6580,7 @@ var HeartbeatExecutor = class {
         toolDeps: this.toolDeps,
         executionContext: {
           workspaceRoot: workspacePath,
+          bundledSkillsDir: this.toolDeps.bundledSkillsDir,
           botTimezone: schedulerService.getTimezone(),
           platform: mainChat.platform,
           chatId: platformChatId,
@@ -6830,6 +7037,7 @@ var SchedulerExecutor = class {
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir: this.toolDeps.bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: this.channelSender.platform,
         chatId: chatIdStr,
@@ -7576,13 +7784,13 @@ function createDatabase({ workspacePath }) {
 }
 
 // src/database/migrate.ts
-import { dirname as dirname6, resolve as resolve4 } from "path";
+import { dirname as dirname7, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-var __dirname = dirname6(fileURLToPath(import.meta.url));
+var __dirname = dirname7(fileURLToPath(import.meta.url));
 function applyMigrations({ workspacePath }) {
   const db = createDatabase({ workspacePath });
-  const migrationsFolder = resolve4(__dirname, "..", "drizzle");
+  const migrationsFolder = resolve5(__dirname, "..", "drizzle");
   migrate(db, { migrationsFolder });
 }
 
@@ -7620,7 +7828,8 @@ var GatewayRuntime = class {
         },
         "Gateway configuration summary"
       );
-      const workspacePath = resolve5(process.cwd(), config.workspace.root);
+      const workspacePath = resolveWorkspaceRoot({ configRoot: config.workspace.root });
+      mkdirSync3(workspacePath, { recursive: true });
       log.info("Applying database migrations...");
       applyMigrations({ workspacePath });
       log.info("Database migrations applied");
@@ -7704,6 +7913,7 @@ var GatewayRuntime = class {
       const adminSocketPath = getAdminSocketPath();
       const toolDeps = {
         workspacePath,
+        bundledSkillsDir: getBundledSkillsDir(),
         aiAgent,
         sessionManager,
         schedulerService,
@@ -7809,6 +8019,16 @@ var GatewayRuntime = class {
               void this.stop().then(() => process.exit(0));
             });
             return { ok: true };
+          },
+          "/reload-skills": async () => {
+            const freshConfig = await loadConfigRaw();
+            if (!freshConfig) {
+              return { ok: false, error: "config_not_found" };
+            }
+            toolDeps.skillsConfig = freshConfig.skills;
+            toolDeps.fullConfig = freshConfig;
+            log.info("Skills configuration reloaded via admin socket");
+            return { ok: true };
           }
         }
       });
@@ -7909,6 +8129,9 @@ var AdminClient = class {
   async shutdown() {
     return this.get({ path: "/shutdown" });
   }
+  async reloadSkills() {
+    return this.get({ path: "/reload-skills" });
+  }
   get({ path }) {
     return new Promise((resolve6, reject) => {
       const req = request(
@@ -7950,6 +8173,7 @@ export {
   AdminClient,
   CONFIG_PATH_ENV_VAR,
   ClawHubError,
+  DEFAULT_WORKSPACE_ROOT,
   GatewayRuntime,
   SUPPORTED_PROVIDERS,
   SkillAlreadyInstalledError,
@@ -7957,14 +8181,19 @@ export {
   createChildLogger,
   createLogger,
   getAdminSocketPath,
+  getBundledSkillPath,
   getConfigPath,
   getDefaultConfigPath,
   getDefaultConfigTemplate,
+  getEnabledBundledSkills,
   getLogger,
+  getSkillKey,
   installSkillFromClawHub,
+  listBundledSkills,
   loadConfig,
   loadConfigRaw,
   resolveLanguageModel,
+  resolveWorkspaceRoot,
   runSkillSetup,
   writeConfig
 };