nexu-io
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎apps/controller/src/services/skillhub-service.ts‎
Lines changed: 15 additions & 1 deletion b/‎apps/controller/src/services/skillhub-service.ts‎
Lines changed: 15 additions & 1 deletion
diff --git a/‎apps/controller/src/services/skillhub/curated-skills.ts‎
Lines changed: 64 additions & 1 deletion b/‎apps/controller/src/services/skillhub/curated-skills.ts‎
Lines changed: 64 additions & 1 deletion
diff --git a/‎apps/controller/tests/replace-libtv-video-from-bundle.test.ts‎
Lines changed: 240 additions & 0 deletions b/‎apps/controller/tests/replace-libtv-video-from-bundle.test.ts‎
Lines changed: 240 additions & 0 deletions
diff --git a/‎apps/controller/tests/skillhub-service.test.ts‎
Lines changed: 7 additions & 0 deletions b/‎apps/controller/tests/skillhub-service.test.ts‎
Lines changed: 7 additions & 0 deletions
@@ -39,3 +39,4 @@ apps/desktop/build-config.json
 .claude/worktrees/
 .task/
 .opencode/
+docs/superpowers/
@@ -1,7 +1,10 @@
 import { existsSync } from "node:fs";
 import type { ControllerEnv } from "../app/env.js";
 import { CatalogManager } from "./skillhub/catalog-manager.js";
-import { copyStaticSkills } from "./skillhub/curated-skills.js";
+import {
+  copyStaticSkills,
+  replaceLibtvVideoFromBundle,
+} from "./skillhub/curated-skills.js";
 import { InstallQueue } from "./skillhub/install-queue.js";
 import { SkillDb } from "./skillhub/skill-db.js";
 import { SkillDirWatcher } from "./skillhub/skill-dir-watcher.js";
@@ -163,6 +166,17 @@ export class SkillhubService {
       if (copied.length > 0) {
         this.db.recordBulkInstall(copied, "managed");
       }
+
+      // Step 1b: Force-refresh libtv-video on every boot so bundled
+      // libtv-video updates (detached background waiter + direct
+      // Feishu delivery) reach existing users on their next app boot.
+      // copyStaticSkills' first-install-only semantics would otherwise
+      // never refresh it. See replaceLibtvVideoFromBundle for rationale.
+      replaceLibtvVideoFromBundle({
+        staticDir: this.env.staticSkillsDir,
+        targetDir: this.env.openclawSkillsDir,
+        skillDb: this.db,
+      });
     }
 
     // Step 2: Enqueue curated skills from ClawHub that aren't on disk yet
 
@@ -1,7 +1,9 @@
-import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
 import type { SkillDb } from "./skill-db.js";
 
+const LIBTV_VIDEO_SLUG = "libtv-video";
+
 /**
  * Skills to install from ClawHub on first launch.
  */
@@ -99,6 +101,67 @@ export function copyStaticSkills(params: {
   return { copied, skipped };
 }
 
+/**
+ * Unconditionally install the latest bundled libtv-video into the state
+ * dir on every controller startup. If a previous copy exists, it is
+ * wiped and replaced; if not, a fresh copy is installed. The managed
+ * ledger record is upserted via `recordInstall`, which also flips any
+ * prior `uninstalled` status back to `installed` (intentional — see
+ * below).
+ *
+ * Why this exists: `copyStaticSkills` only copies a static skill on
+ * first install (both `destDir/SKILL.md` and `knownSlugs.has(slug)`
+ * guards skip thereafter), so bundled libtv-video updates never reach
+ * existing users on an app update. This function is how the libtv-video
+ * refactor (detached background waiter + direct Feishu delivery via
+ * `feishu_send_video.py`) ships to existing users on their next boot.
+ *
+ * Scope constraints:
+ *   - Only libtv-video. Other bundled static skills keep the existing
+ *     first-install-only semantics from `copyStaticSkills`.
+ *   - Only touches `<targetDir>/libtv-video/`. User-scoped copies under
+ *     `~/.agents/skills/libtv-video/` and per-agent workspace copies
+ *     under `<openclawStateDir>/agents/<agentId>/skills/libtv-video/`
+ *     are left alone — they represent explicit user choices under
+ *     different ledger sources.
+ *   - Only modifies the `source: "managed"` ledger record. Workspace /
+ *     user / custom records for the same slug are left untouched.
+ *   - Does NOT respect the managed record's uninstalled status —
+ *     libtv-video is treated as a core bundled capability that always
+ *     tracks the shipped version. `recordInstall` upserts any prior
+ *     `uninstalled` record back to `installed`.
+ *
+ * Why a dedicated function instead of reusing `copyStaticSkills`: its
+ * `knownSlugs.has(slug)` guard skips on any ledger source, so even if
+ * we removed the `managed` record beforehand, any stray workspace or
+ * user record for libtv-video would still cause a silent skip. This
+ * function bypasses that check deterministically.
+ */
+export function replaceLibtvVideoFromBundle(params: {
+  staticDir: string;
+  targetDir: string;
+  skillDb: SkillDb;
+}): {
+  installed: boolean;
+  reason: "bundle-missing" | "fresh-install" | "replaced";
+} {
+  const srcDir = resolve(params.staticDir, LIBTV_VIDEO_SLUG);
+  if (!existsSync(srcDir)) {
+    return { installed: false, reason: "bundle-missing" };
+  }
+
+  const destDir = resolve(params.targetDir, LIBTV_VIDEO_SLUG);
+  const existed = existsSync(destDir);
+  if (existed) {
+    rmSync(destDir, { recursive: true, force: true });
+  }
+  mkdirSync(destDir, { recursive: true });
+  cpSync(srcDir, destDir, { recursive: true });
+  params.skillDb.recordInstall(LIBTV_VIDEO_SLUG, "managed");
+
+  return { installed: true, reason: existed ? "replaced" : "fresh-install" };
+}
+
 export type CuratedInstallResult = {
   installed: string[];
   skipped: string[];
 
@@ -0,0 +1,240 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { replaceLibtvVideoFromBundle } from "../src/services/skillhub/curated-skills.js";
+import { SkillDb } from "../src/services/skillhub/skill-db.js";
+
+/**
+ * Seed a fake bundled libtv-video source directory at <root>/bundle/libtv-video/
+ * containing a minimal SKILL.md and one script file. Content is deterministic
+ * so tests can assert exact equality after the copy.
+ */
+function seedBundle(bundleRoot: string, scriptContent: string): string {
+  const srcDir = resolve(bundleRoot, "libtv-video");
+  mkdirSync(resolve(srcDir, "scripts"), { recursive: true });
+  writeFileSync(
+    resolve(srcDir, "SKILL.md"),
+    [
+      "---",
+      "name: libtv-video",
+      "description: bundled test fixture",
+      "---",
+      "",
+      "# LibTV Video (test fixture)",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+  writeFileSync(
+    resolve(srcDir, "scripts", "libtv_video.py"),
+    scriptContent,
+    "utf8",
+  );
+  return srcDir;
+}
+
+describe("replaceLibtvVideoFromBundle", () => {
+  let workspaceRoot: string;
+  let bundleRoot: string;
+  let targetRoot: string;
+  let ledgerPath: string;
+
+  beforeEach(async () => {
+    workspaceRoot = await mkdtemp(resolve(tmpdir(), "nexu-libtv-refresh-"));
+    bundleRoot = resolve(workspaceRoot, "bundle");
+    targetRoot = resolve(workspaceRoot, "state-skills");
+    ledgerPath = resolve(workspaceRoot, "skill-ledger.json");
+    mkdirSync(bundleRoot, { recursive: true });
+    mkdirSync(targetRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(workspaceRoot, { recursive: true, force: true });
+  });
+
+  it("installs fresh when the state dir is empty and the ledger has no record", async () => {
+    seedBundle(bundleRoot, "# fresh bundle v1\n");
+    const db = await SkillDb.create(ledgerPath);
+
+    const result = replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    expect(result).toEqual({ installed: true, reason: "fresh-install" });
+
+    const destSkillMd = resolve(targetRoot, "libtv-video", "SKILL.md");
+    expect(existsSync(destSkillMd)).toBe(true);
+    expect(readFileSync(destSkillMd, "utf8")).toContain("name: libtv-video");
+
+    const destScript = resolve(
+      targetRoot,
+      "libtv-video",
+      "scripts",
+      "libtv_video.py",
+    );
+    expect(readFileSync(destScript, "utf8")).toBe("# fresh bundle v1\n");
+
+    const installed = db.getAllInstalled();
+    const libtvRecord = installed.find((r) => r.slug === "libtv-video");
+    expect(libtvRecord).toBeDefined();
+    expect(libtvRecord?.source).toBe("managed");
+    expect(libtvRecord?.status).toBe("installed");
+  });
+
+  it("replaces stale state-dir content and keeps the managed record installed", async () => {
+    // First install with bundle v1
+    seedBundle(bundleRoot, "# bundle v1\n");
+    const db = await SkillDb.create(ledgerPath);
+    replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    // Simulate a bundled update: v2 content in the source dir.
+    seedBundle(bundleRoot, "# bundle v2 — refactored\n");
+
+    const result = replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    expect(result).toEqual({ installed: true, reason: "replaced" });
+
+    const destScript = resolve(
+      targetRoot,
+      "libtv-video",
+      "scripts",
+      "libtv_video.py",
+    );
+    expect(readFileSync(destScript, "utf8")).toBe("# bundle v2 — refactored\n");
+
+    const libtvRecord = db
+      .getAllInstalled()
+      .find((r) => r.slug === "libtv-video");
+    expect(libtvRecord?.status).toBe("installed");
+    expect(libtvRecord?.source).toBe("managed");
+  });
+
+  it("resurrects over an uninstalled managed record instead of honoring it", async () => {
+    seedBundle(bundleRoot, "# bundle resurrect\n");
+
+    // Pre-seed the ledger file with an uninstalled managed record so the
+    // newly-created SkillDb parses it through the schema at load time.
+    const seededLedger = {
+      skills: [
+        {
+          slug: "libtv-video",
+          source: "managed",
+          status: "uninstalled",
+          version: null,
+          installedAt: "2024-01-01T00:00:00.000Z",
+          uninstalledAt: "2024-06-01T00:00:00.000Z",
+          agentId: null,
+        },
+      ],
+    };
+    writeFileSync(ledgerPath, JSON.stringify(seededLedger, null, 2), "utf8");
+
+    const db = await SkillDb.create(ledgerPath);
+
+    const result = replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    expect(result).toEqual({ installed: true, reason: "fresh-install" });
+
+    // State dir has the skill and the ledger record is flipped back to
+    // installed — libtv-video is treated as a core bundled capability
+    // that always tracks the shipped version, so uninstall is NOT
+    // honored.
+    const destSkillMd = resolve(targetRoot, "libtv-video", "SKILL.md");
+    expect(existsSync(destSkillMd)).toBe(true);
+
+    const libtvRecord = db
+      .getAllInstalled()
+      .find((r) => r.slug === "libtv-video");
+    expect(libtvRecord?.status).toBe("installed");
+    expect(libtvRecord?.source).toBe("managed");
+  });
+
+  it("leaves workspace records for the same slug untouched", async () => {
+    seedBundle(bundleRoot, "# bundle coexistence\n");
+
+    // Seed ledger with BOTH a managed libtv-video and a workspace-scoped
+    // libtv-video under a specific agent. The refresh must only modify
+    // the managed record.
+    const seededLedger = {
+      skills: [
+        {
+          slug: "libtv-video",
+          source: "managed",
+          status: "installed",
+          version: null,
+          installedAt: "2024-01-01T00:00:00.000Z",
+          uninstalledAt: null,
+          agentId: null,
+        },
+        {
+          slug: "libtv-video",
+          source: "workspace",
+          status: "installed",
+          version: "user-local-v0.1",
+          installedAt: "2024-02-01T00:00:00.000Z",
+          uninstalledAt: null,
+          agentId: "agent-xyz",
+        },
+      ],
+    };
+    writeFileSync(ledgerPath, JSON.stringify(seededLedger, null, 2), "utf8");
+
+    const db = await SkillDb.create(ledgerPath);
+
+    replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    const installed = db.getAllInstalled();
+    const managedRecord = installed.find(
+      (r) => r.slug === "libtv-video" && r.source === "managed",
+    );
+    const workspaceRecord = installed.find(
+      (r) => r.slug === "libtv-video" && r.source === "workspace",
+    );
+
+    // Managed record is still present and installed.
+    expect(managedRecord?.status).toBe("installed");
+
+    // Workspace record is byte-identical to the seeded one — not
+    // clobbered by the refresh.
+    expect(workspaceRecord).toBeDefined();
+    expect(workspaceRecord?.agentId).toBe("agent-xyz");
+    expect(workspaceRecord?.status).toBe("installed");
+    expect(workspaceRecord?.version).toBe("user-local-v0.1");
+    expect(workspaceRecord?.installedAt).toBe("2024-02-01T00:00:00.000Z");
+  });
+
+  it("returns bundle-missing when the bundled source directory is absent", async () => {
+    // Intentionally do NOT seed the bundle.
+    const db = await SkillDb.create(ledgerPath);
+
+    const result = replaceLibtvVideoFromBundle({
+      staticDir: bundleRoot,
+      targetDir: targetRoot,
+      skillDb: db,
+    });
+
+    expect(result).toEqual({ installed: false, reason: "bundle-missing" });
+    expect(existsSync(resolve(targetRoot, "libtv-video"))).toBe(false);
+    expect(db.getAllInstalled()).toHaveLength(0);
+  });
+});
@@ -131,6 +131,11 @@ const mocks = vi.hoisted(() => {
     skipped: [] as string[],
   }));
 
+  const mockReplaceLibtvVideoFromBundle = vi.fn(() => ({
+    installed: false as boolean,
+    reason: "bundle-missing" as "bundle-missing" | "fresh-install" | "replaced",
+  }));
+
   return {
     mockSkillDbCreate,
     catalogManagerInstances,
@@ -140,6 +145,7 @@ const mocks = vi.hoisted(() => {
     dirWatcherInstances,
     MockSkillDirWatcher,
     mockCopyStaticSkills,
+    mockReplaceLibtvVideoFromBundle,
   };
 });
 
@@ -163,6 +169,7 @@ vi.mock("../src/services/skillhub/skill-dir-watcher.js", () => ({
 
 vi.mock("../src/services/skillhub/curated-skills.js", () => ({
   copyStaticSkills: mocks.mockCopyStaticSkills,
+  replaceLibtvVideoFromBundle: mocks.mockReplaceLibtvVideoFromBundle,
 }));
 
 import { SkillhubService } from "../src/services/skillhub-service.js";