@heylemon/lemonade 0.0.5 → 0.0.7

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.5",
-  "commit": "e4c8970d613551e3b0086ba6e128b5624c5f2155",
-  "builtAt": "2026-02-20T05:39:04.795Z"
+  "version": "0.0.7",
+  "commit": "7f0b46cd788721fa1e258a2542070bdb178f32a7",
+  "builtAt": "2026-02-20T06:05:51.160Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-0084b5bec47a901a88b379363f5f31530feeb541ab85d15e5f944c012ebbef96
+3b89844316612a865be1e4c2c9302a4043b8e428920fc2948219aa7e67113aa3

package/dist/gateway/server-startup.js

@@ -8,7 +8,15 @@ import { loadInternalHooks } from "../hooks/loader.js";
 import { startPluginServices } from "../plugins/services.js";
 import { startBrowserControlServerIfEnabled } from "./server-browser.js";
 import { scheduleRestartSentinelWake, shouldWakeFromRestartSentinel, } from "./server-restart-sentinel.js";
+import { pullSkillPreferences } from "./skills-sync.js";
 export async function startGatewaySidecars(params) {
+    // Restore skill preferences from cloud (non-blocking).
+    try {
+        await pullSkillPreferences();
+    }
+    catch (err) {
+        params.log.warn(`skills-sync: pull failed on startup: ${String(err)}`);
+    }
     // Start Lemonade browser control server (unless disabled via config).
     let browserControl = null;
     try {

package/dist/gateway/skills-http.js

@@ -20,6 +20,7 @@ import { resolveBundledSkillsDir } from "../agents/skills/bundled-dir.js";
 import { authorizeGatewayConnect } from "./auth.js";
 import { sendJson, sendMethodNotAllowed, sendUnauthorized, sendInvalidRequest, readJsonBodyOrError, } from "./http-common.js";
 import { getBearerToken } from "./http-utils.js";
+import { pushSkillPreferences } from "./skills-sync.js";
 const fsp = fs.promises;
 /**
  * Handle skills API requests.
@@ -92,6 +93,25 @@ export async function handleSkillsHttpRequest(req, res, opts) {
 }
 // ─── Helpers ───────────────────────────────────────────────────────────────────
 const MANAGED_SKILLS_DIR = path.join(CONFIG_DIR, "skills");
+function getBuiltInSkillNames() {
+    const bundledDir = resolveBundledSkillsDir();
+    if (!bundledDir || !fs.existsSync(bundledDir))
+        return new Set();
+    const loadSkills = (params) => {
+        const loaded = loadSkillsFromDir(params);
+        if (Array.isArray(loaded))
+            return loaded;
+        if (loaded &&
+            typeof loaded === "object" &&
+            "skills" in loaded &&
+            Array.isArray(loaded.skills)) {
+            return loaded.skills;
+        }
+        return [];
+    };
+    const skills = loadSkills({ dir: bundledDir, source: "lemonade-bundled" });
+    return new Set(skills.map((s) => s.name));
+}
 function loadAllSkillEntries() {
     const config = loadConfig();
     const loadSkills = (params) => {
@@ -175,53 +195,68 @@ async function handleCreateSkill(req, res) {
         sendInvalidRequest(res, "name is invalid after sanitization");
         return true;
     }
-    const skillDir = path.join(MANAGED_SKILLS_DIR, safeName);
-    const skillFile = path.join(skillDir, "SKILL.md");
-    // Check if already exists
-    if (fs.existsSync(skillFile)) {
+    const builtInNames = getBuiltInSkillNames();
+    let finalName = safeName;
+    if (builtInNames.has(safeName)) {
+        finalName = `${safeName}-custom`;
+    }
+    const customSkillDir = path.join(MANAGED_SKILLS_DIR, finalName);
+    const customSkillFile = path.join(customSkillDir, "SKILL.md");
+    if (fs.existsSync(customSkillFile)) {
         sendJson(res, 409, {
-            error: { message: `Skill '${safeName}' already exists`, type: "conflict" },
+            error: {
+                message: `You already have a custom skill '${finalName}'. You can replace its content or rename your new skill.`,
+                type: "conflict",
+            },
         });
         return true;
     }
     // Build SKILL.md
     let fileContent;
     if (content.startsWith("---")) {
-        // Content already has frontmatter
         fileContent = content;
     }
     else {
-        fileContent = `---\nname: ${safeName}\ndescription: "${description || "Custom skill"}"\n---\n\n${content}`;
+        fileContent = `---\nname: ${finalName}\ndescription: "${description || "Custom skill"}"\n---\n\n${content}`;
     }
-    await fsp.mkdir(skillDir, { recursive: true });
-    await fsp.writeFile(skillFile, fileContent, "utf-8");
-    // Enable in config
+    await fsp.mkdir(customSkillDir, { recursive: true });
+    await fsp.writeFile(customSkillFile, fileContent, "utf-8");
     const config = loadConfig();
     if (!config.skills)
         config.skills = {};
     if (!config.skills.entries)
         config.skills.entries = {};
-    config.skills.entries[safeName] = { enabled: true };
+    // If this shadows a built-in, disable the built-in and enable the custom one
+    if (finalName !== safeName && builtInNames.has(safeName)) {
+        config.skills.entries[safeName] = { ...config.skills.entries[safeName], enabled: false };
+    }
+    config.skills.entries[finalName] = { enabled: true };
     await writeConfigFile(config);
     sendJson(res, 201, {
         ok: true,
         skill: {
-            name: safeName,
+            name: finalName,
             description: description || "Custom skill",
-            path: skillFile,
+            path: customSkillFile,
             isBuiltIn: false,
             enabled: true,
         },
+        ...(finalName !== safeName
+            ? {
+                note: `Renamed to '${finalName}' because '${safeName}' is a built-in skill. The built-in version has been deactivated.`,
+            }
+            : {}),
     });
+    void pushSkillPreferences().catch(() => { });
     return true;
 }
 async function handleUpdateSkill(req, res, skillName) {
     const body = (await readJsonBodyOrError(req, res, 1_000_000));
     if (!body)
         return true;
+    const builtInNames = getBuiltInSkillNames();
     const config = loadConfig();
     const updated = {};
-    // Update enabled state in config
     if (typeof body.enabled === "boolean") {
         if (!config.skills)
             config.skills = {};
@@ -234,12 +269,19 @@ async function handleUpdateSkill(req, res, skillName) {
         await writeConfigFile(config);
         updated.enabled = body.enabled;
     }
-    // Update content on disk (only for user/managed skills)
     if (typeof body.content === "string") {
+        if (builtInNames.has(skillName)) {
+            sendJson(res, 403, {
+                error: {
+                    message: `'${skillName}' is a built-in skill and its content cannot be modified. You can only enable or disable it.`,
+                    type: "forbidden",
+                },
+            });
+            return true;
+        }
         const skillFile = path.join(MANAGED_SKILLS_DIR, skillName, "SKILL.md");
         if (fs.existsSync(skillFile)) {
             let newContent = body.content.trim();
-            // Ensure frontmatter exists
             if (!newContent.startsWith("---")) {
                 const desc = typeof body.description === "string" ? body.description : "Custom skill";
                 newContent = `---\nname: ${skillName}\ndescription: "${desc}"\n---\n\n${newContent}`;
@@ -258,9 +300,20 @@ async function handleUpdateSkill(req, res, skillName) {
         }
     }
     sendJson(res, 200, { ok: true, updated });
+    void pushSkillPreferences().catch(() => { });
     return true;
 }
 async function handleDeleteSkill(res, skillName) {
+    const builtInNames = getBuiltInSkillNames();
+    if (builtInNames.has(skillName)) {
+        sendJson(res, 403, {
+            error: {
+                message: `'${skillName}' is a built-in skill and cannot be deleted. You can only enable or disable it.`,
+                type: "forbidden",
+            },
+        });
+        return true;
+    }
     const skillDir = path.join(MANAGED_SKILLS_DIR, skillName);
     if (!fs.existsSync(skillDir)) {
         sendJson(res, 404, {
@@ -268,14 +321,25 @@ async function handleDeleteSkill(res, skillName) {
         });
         return true;
     }
-    // Remove directory
     await fsp.rm(skillDir, { recursive: true, force: true });
-    // Remove from config
     const config = loadConfig();
     if (config.skills?.entries?.[skillName]) {
         delete config.skills.entries[skillName];
-        await writeConfigFile(config);
     }
+    // If deleting a custom override (e.g. "pdf-custom"), re-enable the built-in
+    const baseSkillName = skillName.replace(/-custom$/, "");
+    if (baseSkillName !== skillName && builtInNames.has(baseSkillName)) {
+        if (!config.skills)
+            config.skills = {};
+        if (!config.skills.entries)
+            config.skills.entries = {};
+        config.skills.entries[baseSkillName] = {
+            ...config.skills.entries[baseSkillName],
+            enabled: true,
+        };
+    }
+    await writeConfigFile(config);
     sendJson(res, 200, { ok: true, deleted: skillName });
+    void pushSkillPreferences().catch(() => { });
     return true;
 }

package/dist/gateway/skills-sync.js

@@ -0,0 +1,170 @@
+/**
+ * Cloud sync for skill preferences.
+ *
+ * - pushSkillPreferences() — after local skill changes, push to backend
+ * - pullSkillPreferences() — on startup, pull from backend and apply locally
+ *
+ * Uses the Anthropic provider's baseUrl to derive the backend URL,
+ * and the gateway token for auth.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig, writeConfigFile } from "../config/config.js";
+import { CONFIG_DIR } from "../utils.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("skills-sync");
+const fsp = fs.promises;
+const MANAGED_SKILLS_DIR = path.join(CONFIG_DIR, "skills");
+function resolveSyncEndpoint() {
+    const cfg = loadConfig();
+    const token = cfg.gateway?.auth?.token ?? process.env.LEMONADE_GATEWAY_TOKEN ?? undefined;
+    if (!token)
+        return null;
+    const providers = cfg.models?.providers ?? {};
+    let backendBase;
+    for (const key of ["anthropic", "openai"]) {
+        const entry = providers[key];
+        if (entry?.baseUrl?.trim()) {
+            const raw = entry.baseUrl.trim();
+            const idx = raw.indexOf("/api/lemonade/proxy");
+            if (idx > 0) {
+                backendBase = raw.slice(0, idx);
+                break;
+            }
+        }
+    }
+    if (!backendBase)
+        return null;
+    return {
+        url: `${backendBase}/api/lemonade/skills/sync`,
+        token,
+    };
+}
+function collectCurrentState() {
+    const cfg = loadConfig();
+    const preferences = {};
+    const customSkills = {};
+    const entries = cfg.skills?.entries ?? {};
+    for (const [name, entry] of Object.entries(entries)) {
+        if (typeof entry?.enabled === "boolean") {
+            preferences[name] = { enabled: entry.enabled };
+        }
+    }
+    if (fs.existsSync(MANAGED_SKILLS_DIR)) {
+        try {
+            const dirs = fs.readdirSync(MANAGED_SKILLS_DIR, { withFileTypes: true });
+            for (const d of dirs) {
+                if (!d.isDirectory())
+                    continue;
+                const skillFile = path.join(MANAGED_SKILLS_DIR, d.name, "SKILL.md");
+                if (fs.existsSync(skillFile)) {
+                    try {
+                        const content = fs.readFileSync(skillFile, "utf-8");
+                        customSkills[d.name] = { content, description: "" };
+                    }
+                    catch {
+                        // skip unreadable files
+                    }
+                }
+            }
+        }
+        catch {
+            // skip if dir can't be read
+        }
+    }
+    return { preferences, customSkills };
+}
+export async function pushSkillPreferences() {
+    try {
+        const endpoint = resolveSyncEndpoint();
+        if (!endpoint) {
+            log.debug("skills-sync: no backend endpoint configured, skipping push");
+            return;
+        }
+        const { preferences, customSkills } = collectCurrentState();
+        const res = await fetch(endpoint.url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${endpoint.token}`,
+            },
+            body: JSON.stringify({ preferences, customSkills }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok) {
+            log.warn(`skills-sync: push failed (status ${res.status})`);
+        }
+        else {
+            log.info("skills-sync: pushed preferences to cloud");
+        }
+    }
+    catch (err) {
+        log.warn(`skills-sync: push error: ${String(err)}`);
+    }
+}
+export async function pullSkillPreferences() {
+    try {
+        const endpoint = resolveSyncEndpoint();
+        if (!endpoint) {
+            log.debug("skills-sync: no backend endpoint configured, skipping pull");
+            return;
+        }
+        const res = await fetch(endpoint.url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${endpoint.token}`,
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok) {
+            log.warn(`skills-sync: pull failed (status ${res.status})`);
+            return;
+        }
+        const data = (await res.json());
+        if (!data.ok)
+            return;
+        const cloudPrefs = data.preferences ?? {};
+        const cloudCustom = data.customSkills ?? {};
+        if (Object.keys(cloudPrefs).length === 0 && Object.keys(cloudCustom).length === 0) {
+            log.info("skills-sync: no cloud preferences to apply");
+            return;
+        }
+        const cfg = loadConfig();
+        let changed = false;
+        // Apply preference overrides (enabled/disabled)
+        if (Object.keys(cloudPrefs).length > 0) {
+            if (!cfg.skills)
+                cfg.skills = {};
+            if (!cfg.skills.entries)
+                cfg.skills.entries = {};
+            for (const [name, pref] of Object.entries(cloudPrefs)) {
+                const current = cfg.skills.entries[name];
+                if (!current || current.enabled !== pref.enabled) {
+                    cfg.skills.entries[name] = { ...current, enabled: pref.enabled };
+                    changed = true;
+                }
+            }
+        }
+        // Restore custom skills (write SKILL.md files)
+        let customCount = 0;
+        for (const [name, skill] of Object.entries(cloudCustom)) {
+            if (!skill.content?.trim())
+                continue;
+            const skillDir = path.join(MANAGED_SKILLS_DIR, name);
+            const skillFile = path.join(skillDir, "SKILL.md");
+            // Only write if the file doesn't already exist locally
+            if (!fs.existsSync(skillFile)) {
+                await fsp.mkdir(skillDir, { recursive: true });
+                await fsp.writeFile(skillFile, skill.content, "utf-8");
+                customCount++;
+            }
+        }
+        if (changed) {
+            await writeConfigFile(cfg);
+        }
+        log.info(`skills-sync: pulled preferences from cloud (${Object.keys(cloudPrefs).length} prefs, ${customCount} custom skills restored)`);
+    }
+    catch (err) {
+        log.warn(`skills-sync: pull error: ${String(err)}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"