@heylemon/lemonade 0.0.6 → 0.0.7

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.6",
-  "commit": "726ef3eb29cf96569eaa0380126b995c82e43cf3",
-  "builtAt": "2026-02-20T05:47:58.066Z"
+  "version": "0.0.7",
+  "commit": "7f0b46cd788721fa1e258a2542070bdb178f32a7",
+  "builtAt": "2026-02-20T06:05:51.160Z"
 }

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

@@ -1 +1 @@
-51eb12e5a38916af8a01151207c0974086f45b5a7c962e824bb8ebd5fe8887d1
+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.
@@ -241,9 +242,12 @@ async function handleCreateSkill(req, res) {
             enabled: true,
         },
         ...(finalName !== safeName
-            ? { note: `Renamed to '${finalName}' because '${safeName}' is a built-in skill. The built-in version has been deactivated.` }
+            ? {
+                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) {
@@ -296,6 +300,7 @@ async function handleUpdateSkill(req, res, skillName) {
         }
     }
     sendJson(res, 200, { ok: true, updated });
+    void pushSkillPreferences().catch(() => { });
     return true;
 }
 async function handleDeleteSkill(res, skillName) {
@@ -328,9 +333,13 @@ async function handleDeleteSkill(res, skillName) {
             config.skills = {};
         if (!config.skills.entries)
             config.skills.entries = {};
-        config.skills.entries[baseSkillName] = { ...config.skills.entries[baseSkillName], enabled: true };
+        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.6",
+  "version": "0.0.7",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"