@babyclaw/gateway 0.0.0 → 0.2.0

package/dist/main.js

@@ -139,7 +139,8 @@ function looksLikeSecret({ value }) {
 }
 
 // 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 {
@@ -1945,9 +1946,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
@@ -3704,10 +3722,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,
@@ -3765,6 +3798,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
@@ -3904,6 +3943,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
@@ -3940,6 +3985,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
@@ -4120,44 +4171,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
@@ -4167,54 +4189,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,
@@ -4229,6 +4281,90 @@ 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`
+  }));
+}
+
+// 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,
@@ -4241,7 +4377,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 };
 }
@@ -4422,6 +4562,7 @@ var AgentTurnOrchestrator = class {
     if (abortSignal.aborted) return;
     const {
       workspacePath,
+      bundledSkillsDir,
       aiAgent,
       sessionManager,
       schedulerService,
@@ -4521,6 +4662,7 @@ ${description}`;
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: event.platform,
         chatId: event.chatId,
@@ -5835,11 +5977,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");
@@ -5851,6 +5993,18 @@ function getConfigPath() {
   }
   return getDefaultConfigPath();
 }
+function getConfigDir() {
+  return dirname5(getConfigPath());
+}
+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";
@@ -6004,9 +6158,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),
@@ -6066,7 +6220,7 @@ var DEFAULT_CONFIG_TEMPLATE = {
     timezone: "UTC"
   },
   workspace: {
-    root: "."
+    root: "~/babyclaw"
   },
   session: {
     maxMessagesPerSession: 120,
@@ -6123,6 +6277,22 @@ ${issues}`);
   log.info({ configPath }, "Configuration validated successfully");
   return parsed.data;
 }
+async function loadConfigRaw() {
+  const configPath = getConfigPath();
+  try {
+    await access(configPath);
+  } catch {
+    return null;
+  }
+  const raw = await readFile8(configPath, "utf8");
+  const json = parseJsonConfig({ raw, configPath });
+  normalizeLegacyTelegramConfig({ json });
+  const parsed = babyclawConfigSchema.safeParse(json);
+  if (!parsed.success) {
+    return null;
+  }
+  return parsed.data;
+}
 async function ensureConfigFileExists({ configPath }) {
   try {
     await access(configPath);
@@ -6131,7 +6301,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.");
   }
@@ -6303,6 +6473,7 @@ var HeartbeatExecutor = class {
         toolDeps: this.toolDeps,
         executionContext: {
           workspaceRoot: workspacePath,
+          bundledSkillsDir: this.toolDeps.bundledSkillsDir,
           botTimezone: schedulerService.getTimezone(),
           platform: mainChat.platform,
           chatId: platformChatId,
@@ -6759,6 +6930,7 @@ var SchedulerExecutor = class {
       toolDeps: this.toolDeps,
       executionContext: {
         workspaceRoot: workspacePath,
+        bundledSkillsDir: this.toolDeps.bundledSkillsDir,
         botTimezone: schedulerService.getTimezone(),
         platform: this.channelSender.platform,
         chatId: chatIdStr,
@@ -7505,13 +7677,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 });
 }
 
@@ -7549,7 +7721,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");
@@ -7633,6 +7806,7 @@ var GatewayRuntime = class {
       const adminSocketPath = getAdminSocketPath();
       const toolDeps = {
         workspacePath,
+        bundledSkillsDir: getBundledSkillsDir(),
         aiAgent,
         sessionManager,
         schedulerService,
@@ -7738,6 +7912,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 };
           }
         }
       });