@storyclaw/talenthub 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { agentInstall } from "./commands/agent-install.js";
+import { agentList } from "./commands/agent-list.js";
+import { agentPublish } from "./commands/agent-publish.js";
+import { agentSearch } from "./commands/agent-search.js";
+import { agentUninstall } from "./commands/agent-uninstall.js";
+import { agentUnpublish } from "./commands/agent-unpublish.js";
+import { agentUpdate } from "./commands/agent-update.js";
+import { login } from "./commands/login.js";
+import { logout } from "./commands/logout.js";
+const program = new Command();
+program
+    .name("talenthub")
+    .description("Manage StoryClaw AI agents")
+    .version("0.1.0");
+program.command("login").description("Authenticate with StoryClaw").action(login);
+program.command("logout").description("Remove stored credentials").action(logout);
+const agent = program.command("agent").description("Agent management commands");
+agent
+    .command("install <name>")
+    .description("Install an agent and its skills")
+    .option("-f, --force", "Overwrite existing agent", false)
+    .action(agentInstall);
+agent
+    .command("update [name]")
+    .description("Update an agent or all agents")
+    .option("-a, --all", "Update all installed agents")
+    .action(agentUpdate);
+agent
+    .command("uninstall <name>")
+    .description("Remove an installed agent")
+    .option("-y, --yes", "Skip confirmation prompt")
+    .action(agentUninstall);
+agent
+    .command("list")
+    .description("List installed agents and check for updates")
+    .action(agentList);
+agent
+    .command("search [query]")
+    .description("Browse available agents")
+    .action(agentSearch);
+agent
+    .command("publish <name>")
+    .description("Publish a local agent to the registry")
+    .option("-d, --dir <path>", "Agent directory containing manifest.json and .md files")
+    .action(agentPublish);
+agent
+    .command("unpublish <name>")
+    .description("Archive an agent from the registry")
+    .action(agentUnpublish);
+program.parse();

package/dist/commands/agent-install.d.ts

@@ -0,0 +1,3 @@
+export declare function agentInstall(name: string, options: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/agent-install.js

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isClawhubAvailable, installSkill } from "../lib/clawhub.js";
+import { addOrUpdateAgent, findAgentEntry, readConfig, writeConfig } from "../lib/config.js";
+import { fetchCatalog, fetchManifest } from "../lib/registry.js";
+import { resolveWorkspaceDir } from "../lib/paths.js";
+import { markInstalled } from "../lib/state.js";
+export async function agentInstall(name, options) {
+    console.log(`Looking up agent "${name}"...`);
+    const catalog = await fetchCatalog();
+    if (!catalog.agents[name]) {
+        const available = Object.keys(catalog.agents).join(", ");
+        console.error(`Agent "${name}" not found. Available: ${available}`);
+        process.exit(1);
+    }
+    const manifest = await fetchManifest(name);
+    console.log(`Found ${manifest.emoji} ${manifest.name} v${manifest.version} (${manifest.skills.length} skills)`);
+    const cfg = readConfig();
+    const existing = findAgentEntry(cfg, name);
+    if (existing && !options.force) {
+        console.error(`Agent "${name}" already exists in config. Use --force to overwrite.`);
+        process.exit(1);
+    }
+    const hasClawhub = isClawhubAvailable();
+    const wsDir = resolveWorkspaceDir(name);
+    fs.mkdirSync(wsDir, { recursive: true });
+    console.log("Writing agent files...");
+    if (manifest.files) {
+        for (const [filename, content] of Object.entries(manifest.files)) {
+            if (content) {
+                fs.writeFileSync(path.join(wsDir, filename), content, "utf-8");
+            }
+        }
+    }
+    let installed = 0;
+    let failed = 0;
+    if (hasClawhub && manifest.skills.length > 0) {
+        console.log(`Installing ${manifest.skills.length} skills via clawhub...`);
+        for (const skill of manifest.skills) {
+            const ok = installSkill(skill, wsDir);
+            if (ok)
+                installed++;
+            else
+                failed++;
+        }
+    }
+    else if (!hasClawhub && manifest.skills.length > 0) {
+        console.log(`Skipping ${manifest.skills.length} skills (clawhub not installed).`);
+        console.log("Install clawhub later: npm i -g clawhub");
+        console.log(`Then run: talenthub agent update ${name}`);
+    }
+    let updatedCfg = addOrUpdateAgent(cfg, {
+        id: manifest.id,
+        name: manifest.name,
+        skills: manifest.skills,
+        model: manifest.model,
+    });
+    writeConfig(updatedCfg);
+    markInstalled(manifest.id, manifest.version);
+    console.log(`\n${manifest.emoji} Installed ${manifest.name}` +
+        (installed > 0 ? ` with ${installed} skills` : "") +
+        (failed > 0 ? ` (${failed} failed)` : "") +
+        (!hasClawhub && manifest.skills.length > 0
+            ? " (skills pending — install clawhub)"
+            : "") +
+        ".");
+    console.log("Restart the OpenClaw gateway to apply changes.");
+}

package/dist/commands/agent-list.d.ts

@@ -0,0 +1 @@
+export declare function agentList(): Promise<void>;

package/dist/commands/agent-list.js

@@ -0,0 +1,36 @@
+import { readState } from "../lib/state.js";
+import { getCatalogCached } from "../lib/update-check.js";
+export async function agentList() {
+    const state = readState();
+    const agents = Object.entries(state.agents);
+    if (agents.length === 0) {
+        console.log("No agents installed via talenthub.");
+        console.log('Run "talenthub agent search" to see available agents.');
+        return;
+    }
+    let catalog;
+    try {
+        catalog = await getCatalogCached();
+    }
+    catch {
+        catalog = null;
+    }
+    const header = padRow("Agent", "Version", "Skills", "Status");
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const [id, info] of agents) {
+        const remote = catalog?.agents[id];
+        const skillCount = remote?.skillCount?.toString() ?? "?";
+        let status = "Up to date";
+        if (remote && remote.version !== info.version) {
+            status = `Update available (${remote.version})`;
+        }
+        else if (!remote) {
+            status = "Not in registry";
+        }
+        console.log(padRow(id, info.version, skillCount, status));
+    }
+}
+function padRow(name, version, skills, status) {
+    return `  ${name.padEnd(16)} ${version.padEnd(14)} ${skills.padEnd(8)} ${status}`;
+}

package/dist/commands/agent-publish.d.ts

@@ -0,0 +1,3 @@
+export declare function agentPublish(name: string, opts: {
+    dir?: string;
+}): Promise<void>;

package/dist/commands/agent-publish.js

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { readAuth, getRegistryBaseUrl } from "../lib/auth.js";
+import { findAgentEntry, readConfig } from "../lib/config.js";
+import { resolveWorkspaceDir } from "../lib/paths.js";
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+const MAX_FILE_SIZE = 200 * 1024;
+const MAX_TOTAL_SIZE = 1024 * 1024;
+function readAgentDir(dir) {
+    if (!fs.existsSync(dir)) {
+        console.error(`Directory not found: ${dir}`);
+        process.exit(1);
+    }
+    let manifest = {};
+    const manifestPath = path.join(dir, "manifest.json");
+    if (fs.existsSync(manifestPath)) {
+        try {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        }
+        catch {
+            console.warn("Warning: could not parse manifest.json.");
+        }
+    }
+    const files = {};
+    let totalSize = 0;
+    for (const filename of ["IDENTITY.md", "USER.md", "SOUL.md", "AGENTS.md"]) {
+        const p = path.join(dir, filename);
+        if (fs.existsSync(p)) {
+            const content = fs.readFileSync(p, "utf-8");
+            const size = Buffer.byteLength(content, "utf-8");
+            if (size > MAX_FILE_SIZE) {
+                console.error(`${filename} exceeds 200KB limit (${Math.round(size / 1024)}KB).`);
+                process.exit(1);
+            }
+            totalSize += size;
+            files[filename] = content;
+        }
+    }
+    if (totalSize > MAX_TOTAL_SIZE) {
+        console.error(`Total prompt content exceeds 1MB limit (${Math.round(totalSize / 1024)}KB).`);
+        process.exit(1);
+    }
+    return { manifest, files };
+}
+export async function agentPublish(name, opts) {
+    const auth = readAuth();
+    if (!auth) {
+        console.error("Not logged in. Run \"talenthub login\" first.");
+        process.exit(1);
+    }
+    let manifest;
+    let files;
+    let fallbackName = name;
+    let fallbackModel = "claude-sonnet-4-5";
+    let fallbackSkills = [];
+    if (opts.dir) {
+        const agentDir = path.resolve(opts.dir);
+        ({ manifest, files } = readAgentDir(agentDir));
+    }
+    else {
+        const cfg = readConfig();
+        const entry = findAgentEntry(cfg, name);
+        if (!entry) {
+            console.error(`Agent "${name}" not found in openclaw config.`);
+            console.error("Use --dir to publish from an agent directory, or install the agent first.");
+            process.exit(1);
+        }
+        fallbackName = entry.name || name;
+        fallbackModel = entry.model || fallbackModel;
+        fallbackSkills = entry.skills || [];
+        const wsDir = resolveWorkspaceDir(name);
+        ({ manifest, files } = readAgentDir(wsDir));
+    }
+    const agentId = manifest.id || name;
+    const currentVersion = manifest.version || "0.1.0";
+    const version = await prompt(`Version [${currentVersion}]: `);
+    const finalVersion = version || currentVersion;
+    const payload = {
+        id: agentId,
+        version: finalVersion,
+        name: manifest.name || fallbackName,
+        emoji: manifest.emoji || "",
+        role: manifest.role || "",
+        tagline: manifest.tagline || "",
+        description: manifest.description || "",
+        category: manifest.category || "productivity",
+        model: manifest.model || fallbackModel,
+        skills: manifest.skills || fallbackSkills,
+        identity_prompt: files["IDENTITY.md"] || "",
+        user_prompt: files["USER.md"] || "",
+        soul_prompt: files["SOUL.md"] || "",
+        agents_prompt: files["AGENTS.md"] || "",
+        min_openclaw_version: manifest.minOpenClawVersion || null,
+        avatar_url: manifest.avatarUrl || null,
+    };
+    console.log(`\nPublishing ${payload.emoji || ""} ${payload.name} v${finalVersion}...`);
+    const base = getRegistryBaseUrl();
+    const res = await fetch(`${base}/api/talent/registry/publish`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${auth.token}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    const result = await res.json().catch(() => ({ error: "Unknown error" }));
+    if (!res.ok) {
+        console.error(`\n✗ Publish failed: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`\n✓ ${result.message}`);
+}

package/dist/commands/agent-search.d.ts

@@ -0,0 +1 @@
+export declare function agentSearch(query?: string): Promise<void>;

package/dist/commands/agent-search.js

@@ -0,0 +1,28 @@
+import { readState } from "../lib/state.js";
+import { getCatalogCached } from "../lib/update-check.js";
+export async function agentSearch(query) {
+    const catalog = await getCatalogCached();
+    const state = readState();
+    let entries = Object.entries(catalog.agents);
+    if (query) {
+        const q = query.toLowerCase();
+        entries = entries.filter(([id, a]) => id.includes(q) ||
+            a.name.toLowerCase().includes(q) ||
+            a.category.toLowerCase().includes(q));
+    }
+    if (entries.length === 0) {
+        console.log(query ? `No agents matching "${query}".` : "No agents available.");
+        return;
+    }
+    const header = padRow("", "Agent", "Name", "Category", "Skills", "Version");
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const [id, agent] of entries) {
+        const installed = state.agents[id] ? "✓" : " ";
+        console.log(padRow(installed, id, `${agent.emoji} ${agent.name}`, agent.category, agent.skillCount.toString(), agent.version));
+    }
+    console.log(`\n${entries.length} agent(s) found. ✓ = installed`);
+}
+function padRow(mark, id, name, category, skills, version) {
+    return `  ${mark.padEnd(2)} ${id.padEnd(14)} ${name.padEnd(32)} ${category.padEnd(14)} ${skills.padEnd(8)} ${version}`;
+}

package/dist/commands/agent-uninstall.d.ts

@@ -0,0 +1,3 @@
+export declare function agentUninstall(name: string, options: {
+    yes?: boolean;
+}): Promise<void>;

package/dist/commands/agent-uninstall.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import readline from "node:readline";
+import { readConfig, removeAgent, writeConfig } from "../lib/config.js";
+import { resolveWorkspaceDir } from "../lib/paths.js";
+import { markUninstalled, readState } from "../lib/state.js";
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase().startsWith("y"));
+        });
+    });
+}
+export async function agentUninstall(name, options) {
+    const state = readState();
+    if (!state.agents[name]) {
+        console.error(`Agent "${name}" is not installed via talenthub.`);
+        process.exit(1);
+    }
+    if (!options.yes) {
+        const ok = await confirm(`Remove agent "${name}"? This will archive the workspace. [y/N] `);
+        if (!ok) {
+            console.log("Cancelled.");
+            return;
+        }
+    }
+    // Archive workspace
+    const wsDir = resolveWorkspaceDir(name);
+    if (fs.existsSync(wsDir)) {
+        const backupDir = `${wsDir}.bak`;
+        if (fs.existsSync(backupDir)) {
+            fs.rmSync(backupDir, { recursive: true, force: true });
+        }
+        fs.renameSync(wsDir, backupDir);
+        console.log(`Workspace archived to ${backupDir}`);
+    }
+    // Remove from config
+    const cfg = readConfig();
+    const { config: updatedCfg, removedBindings } = removeAgentFromConfig(cfg, name);
+    writeConfig(updatedCfg);
+    markUninstalled(name);
+    console.log(`Removed agent "${name}"` +
+        (removedBindings > 0 ? ` (${removedBindings} binding(s) cleaned)` : "") +
+        ".");
+    console.log("Restart the OpenClaw gateway to apply changes.");
+}
+function removeAgentFromConfig(cfg, agentId) {
+    const result = removeAgent(cfg, agentId);
+    const originalBindings = cfg.bindings?.length ?? 0;
+    const newBindings = (result.bindings ?? []).length;
+    return {
+        config: result,
+        removedBindings: originalBindings - newBindings,
+    };
+}

package/dist/commands/agent-unpublish.d.ts

@@ -0,0 +1 @@
+export declare function agentUnpublish(name: string): Promise<void>;

package/dist/commands/agent-unpublish.js

@@ -0,0 +1,37 @@
+import readline from "node:readline";
+import { readAuth, getRegistryBaseUrl } from "../lib/auth.js";
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase().startsWith("y"));
+        });
+    });
+}
+export async function agentUnpublish(name) {
+    const auth = readAuth();
+    if (!auth) {
+        console.error("Not logged in. Run \"talenthub login\" first.");
+        process.exit(1);
+    }
+    const ok = await confirm(`Unpublish agent "${name}"? It will be hidden but data is preserved. [y/N] `);
+    if (!ok) {
+        console.log("Cancelled.");
+        return;
+    }
+    const base = getRegistryBaseUrl();
+    const res = await fetch(`${base}/api/talent/registry/${name}/unpublish`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${auth.token}`,
+        },
+    });
+    const result = await res.json().catch(() => ({ error: "Unknown error" }));
+    if (!res.ok) {
+        console.error(`✗ Unpublish failed: ${result.error}`);
+        process.exit(1);
+    }
+    console.log(`✓ ${result.message}`);
+}

package/dist/commands/agent-update.d.ts

@@ -0,0 +1,3 @@
+export declare function agentUpdate(name?: string, options?: {
+    all?: boolean;
+}): Promise<void>;

package/dist/commands/agent-update.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ensureClawhub, installSkill, updateAllSkills } from "../lib/clawhub.js";
+import { addOrUpdateAgent, readConfig, writeConfig } from "../lib/config.js";
+import { fetchManifest } from "../lib/registry.js";
+import { resolveWorkspaceDir } from "../lib/paths.js";
+import { markInstalled, readState } from "../lib/state.js";
+import { checkUpdates } from "../lib/update-check.js";
+async function updateAgent(agentId) {
+    const manifest = await fetchManifest(agentId);
+    const wsDir = resolveWorkspaceDir(agentId);
+    // Backup workspace
+    const backupDir = `${wsDir}.bak`;
+    if (fs.existsSync(wsDir)) {
+        if (fs.existsSync(backupDir)) {
+            fs.rmSync(backupDir, { recursive: true, force: true });
+        }
+        fs.cpSync(wsDir, backupDir, { recursive: true });
+    }
+    fs.mkdirSync(wsDir, { recursive: true });
+    // Write agent files from the registry response
+    if (manifest.files) {
+        for (const [filename, content] of Object.entries(manifest.files)) {
+            if (content) {
+                fs.writeFileSync(path.join(wsDir, filename), content, "utf-8");
+            }
+        }
+    }
+    // Determine new skills to install
+    const lockPath = path.join(wsDir, ".clawhub", "lock.json");
+    const existingSkills = new Set();
+    if (fs.existsSync(lockPath)) {
+        try {
+            const lock = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+            for (const entry of lock.skills ?? []) {
+                if (entry.slug)
+                    existingSkills.add(entry.slug);
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    const newSkills = manifest.skills.filter((s) => !existingSkills.has(s));
+    if (newSkills.length > 0) {
+        ensureClawhub();
+        for (const skill of newSkills) {
+            installSkill(skill, wsDir);
+        }
+    }
+    // Update all existing skills
+    updateAllSkills(wsDir);
+    // Update config
+    const cfg = readConfig();
+    const updatedCfg = addOrUpdateAgent(cfg, {
+        id: manifest.id,
+        name: manifest.name,
+        skills: manifest.skills,
+        model: manifest.model,
+    });
+    writeConfig(updatedCfg);
+    markInstalled(manifest.id, manifest.version);
+    return true;
+}
+export async function agentUpdate(name, options) {
+    if (options?.all || !name) {
+        const updates = await checkUpdates();
+        if (updates.length === 0) {
+            console.log("All agents are up to date.");
+            return;
+        }
+        ensureClawhub();
+        console.log(`Found ${updates.length} update(s):\n`);
+        for (const u of updates) {
+            console.log(`  Updating ${u.name}: ${u.currentVersion} → ${u.latestVersion}`);
+            await updateAgent(u.agentId);
+            console.log(`  ✓ ${u.name} updated to ${u.latestVersion}`);
+        }
+        console.log("\nRestart the OpenClaw gateway to apply changes.");
+        return;
+    }
+    const state = readState();
+    if (!state.agents[name]) {
+        console.error(`Agent "${name}" is not installed. Use "talenthub agent install ${name}" first.`);
+        process.exit(1);
+    }
+    ensureClawhub();
+    console.log(`Updating agent "${name}"...`);
+    await updateAgent(name);
+    console.log(`✓ Agent "${name}" updated. Restart the OpenClaw gateway to apply changes.`);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function login(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,42 @@
+import { execSync } from "node:child_process";
+import { readAuth, requestDeviceCode, pollForToken, writeAuth } from "../lib/auth.js";
+function openUrl(url) {
+    try {
+        const cmd = process.platform === "darwin"
+            ? `open "${url}"`
+            : process.platform === "win32"
+                ? `start "${url}"`
+                : `xdg-open "${url}"`;
+        execSync(cmd, { stdio: "ignore" });
+    }
+    catch {
+        // Browser open is best-effort
+    }
+}
+export async function login() {
+    const existing = readAuth();
+    if (existing) {
+        console.log("Already logged in.");
+        console.log(`  User ID: ${existing.user_id}`);
+        console.log(`  Expires: ${existing.expires_at}`);
+        console.log('Run "talenthub logout" first to re-authenticate.');
+        return;
+    }
+    console.log("Requesting device code...");
+    const { device_code, user_code, verification_url, interval, expires_in } = await requestDeviceCode();
+    console.log(`\nOpen this URL in your browser to authorize:\n`);
+    console.log(`  ${verification_url}\n`);
+    console.log(`Your code: ${user_code}\n`);
+    console.log("Waiting for authorization...");
+    openUrl(verification_url);
+    try {
+        const { access_token, user_id, expires_at } = await pollForToken(device_code, interval, expires_in * 1000);
+        writeAuth({ token: access_token, user_id, expires_at });
+        console.log(`\n✓ Logged in successfully.`);
+        console.log(`  User ID: ${user_id}`);
+    }
+    catch (err) {
+        console.error(`\n✗ Login failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logout(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,10 @@
+import { clearAuth, readAuth } from "../lib/auth.js";
+export async function logout() {
+    const existing = readAuth();
+    if (!existing) {
+        console.log("Not logged in.");
+        return;
+    }
+    clearAuth();
+    console.log("✓ Logged out. Token removed.");
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,23 @@
+export type AuthData = {
+    token: string;
+    user_id: string;
+    expires_at: string;
+};
+export declare function readAuth(): AuthData | null;
+export declare function writeAuth(data: AuthData): void;
+export declare function clearAuth(): void;
+export declare function getRegistryBaseUrl(): string;
+export type DeviceCodeResponse = {
+    device_code: string;
+    user_code: string;
+    verification_url: string;
+    expires_in: number;
+    interval: number;
+};
+export declare function requestDeviceCode(): Promise<DeviceCodeResponse>;
+export type TokenResponse = {
+    access_token: string;
+    user_id: string;
+    expires_at: string;
+};
+export declare function pollForToken(deviceCode: string, interval: number, maxWaitMs: number): Promise<TokenResponse>;

package/dist/lib/auth.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "./paths.js";
+function authFilePath() {
+    return path.join(resolveStateDir(), "talenthub-auth.json");
+}
+export function readAuth() {
+    const p = authFilePath();
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+        if (data.expires_at && new Date(data.expires_at) < new Date()) {
+            fs.unlinkSync(p);
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeAuth(data) {
+    const p = authFilePath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+export function clearAuth() {
+    const p = authFilePath();
+    if (fs.existsSync(p)) {
+        fs.unlinkSync(p);
+    }
+}
+export function getRegistryBaseUrl() {
+    return (process.env.TALENTHUB_URL?.trim() ||
+        process.env.TALENTHUB_REGISTRY?.trim() ||
+        "https://app.storyclaw.com");
+}
+export async function requestDeviceCode() {
+    const base = getRegistryBaseUrl();
+    const res = await fetch(`${base}/api/talent/auth/device-code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to request device code: ${res.status}`);
+    }
+    return res.json();
+}
+export async function pollForToken(deviceCode, interval, maxWaitMs) {
+    const base = getRegistryBaseUrl();
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+        const res = await fetch(`${base}/api/talent/auth/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ device_code: deviceCode }),
+        });
+        if (res.ok) {
+            return res.json();
+        }
+        const body = await res.json().catch(() => ({ error: "unknown" }));
+        if (body.error === "authorization_pending") {
+            continue;
+        }
+        if (body.error === "expired_token") {
+            throw new Error("Device code expired. Please try again.");
+        }
+        throw new Error(`Token exchange failed: ${body.error}`);
+    }
+    throw new Error("Timed out waiting for authorization.");
+}

package/dist/lib/clawhub.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureClawhub(): void;
+export declare function isClawhubAvailable(): boolean;
+export declare function installSkill(slug: string, workdir: string): boolean;
+export declare function updateAllSkills(workdir: string): boolean;

package/dist/lib/clawhub.js

@@ -0,0 +1,45 @@
+import { execSync } from "node:child_process";
+function hasClawhub() {
+    try {
+        execSync("clawhub --version", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function ensureClawhub() {
+    if (!hasClawhub()) {
+        console.error("Error: clawhub CLI is not installed.\n" +
+            "Install it with: npm i -g clawhub\n" +
+            "Then retry.");
+        process.exit(1);
+    }
+}
+export function isClawhubAvailable() {
+    return hasClawhub();
+}
+export function installSkill(slug, workdir) {
+    try {
+        execSync(`clawhub install ${slug} --workdir "${workdir}" --no-input`, {
+            stdio: "inherit",
+        });
+        return true;
+    }
+    catch {
+        console.error(`  Warning: failed to install skill "${slug}"`);
+        return false;
+    }
+}
+export function updateAllSkills(workdir) {
+    try {
+        execSync(`clawhub update --all --workdir "${workdir}" --no-input`, {
+            stdio: "inherit",
+        });
+        return true;
+    }
+    catch {
+        console.error(`  Warning: failed to update skills in ${workdir}`);
+        return false;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,34 @@
+export type AgentEntry = {
+    id: string;
+    name?: string;
+    workspace?: string;
+    agentDir?: string;
+    model?: string;
+    skills?: string[];
+    [key: string]: unknown;
+};
+export type OpenClawConfig = {
+    agents?: {
+        list?: AgentEntry[];
+        defaults?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    bindings?: Array<{
+        agentId: string;
+        [key: string]: unknown;
+    }>;
+    tools?: {
+        agentToAgent?: {
+            allow?: string[];
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+export declare function readConfig(): OpenClawConfig;
+export declare function writeConfig(cfg: OpenClawConfig): void;
+export declare function findAgentEntry(cfg: OpenClawConfig, agentId: string): AgentEntry | undefined;
+export declare function findAgentIndex(cfg: OpenClawConfig, agentId: string): number;
+export declare function addOrUpdateAgent(cfg: OpenClawConfig, entry: AgentEntry): OpenClawConfig;
+export declare function removeAgent(cfg: OpenClawConfig, agentId: string): OpenClawConfig;

package/dist/lib/config.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import { resolveConfigPath } from "./paths.js";
+export function readConfig() {
+    const configPath = resolveConfigPath();
+    if (!fs.existsSync(configPath))
+        return {};
+    const raw = fs.readFileSync(configPath, "utf-8");
+    // JSON5-like: strip comments, trailing commas (basic approach)
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // Try stripping single-line comments and trailing commas
+        const cleaned = raw
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/,(\s*[}\]])/g, "$1");
+        return JSON.parse(cleaned);
+    }
+}
+export function writeConfig(cfg) {
+    const configPath = resolveConfigPath();
+    fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}
+export function findAgentEntry(cfg, agentId) {
+    const id = agentId.toLowerCase();
+    return cfg.agents?.list?.find((e) => e.id?.toLowerCase() === id);
+}
+export function findAgentIndex(cfg, agentId) {
+    const id = agentId.toLowerCase();
+    return cfg.agents?.list?.findIndex((e) => e.id?.toLowerCase() === id) ?? -1;
+}
+export function addOrUpdateAgent(cfg, entry) {
+    const list = [...(cfg.agents?.list ?? [])];
+    const idx = findAgentIndex(cfg, entry.id);
+    if (idx >= 0) {
+        list[idx] = { ...list[idx], ...entry };
+    }
+    else {
+        list.push(entry);
+    }
+    return { ...cfg, agents: { ...cfg.agents, list } };
+}
+export function removeAgent(cfg, agentId) {
+    const id = agentId.toLowerCase();
+    const list = (cfg.agents?.list ?? []).filter((e) => e.id?.toLowerCase() !== id);
+    const bindings = (cfg.bindings ?? []).filter((b) => b.agentId?.toLowerCase() !== id);
+    const allow = (cfg.tools?.agentToAgent?.allow ?? []).filter((a) => a.toLowerCase() !== id);
+    return {
+        ...cfg,
+        agents: { ...cfg.agents, list: list.length > 0 ? list : undefined },
+        bindings: bindings.length > 0 ? bindings : undefined,
+        tools: cfg.tools
+            ? {
+                ...cfg.tools,
+                agentToAgent: cfg.tools.agentToAgent
+                    ? { ...cfg.tools.agentToAgent, allow: allow.length > 0 ? allow : undefined }
+                    : undefined,
+            }
+            : undefined,
+    };
+}

package/dist/lib/github.d.ts

@@ -0,0 +1,26 @@
+export type CatalogAgent = {
+    version: string;
+    name: string;
+    emoji: string;
+    category: string;
+    skillCount: number;
+};
+export type Catalog = {
+    catalogVersion: number;
+    updatedAt: string;
+    agents: Record<string, CatalogAgent>;
+};
+export type AgentManifest = {
+    id: string;
+    version: string;
+    name: string;
+    emoji: string;
+    model: string;
+    category: string;
+    minOpenClawVersion: string;
+    skills: string[];
+    files: string[];
+};
+export declare function fetchCatalog(): Promise<Catalog>;
+export declare function fetchManifest(agentId: string): Promise<AgentManifest>;
+export declare function fetchAgentFile(agentId: string, filename: string): Promise<string>;

package/dist/lib/github.js

@@ -0,0 +1,29 @@
+const DEFAULT_REGISTRY = "https://app.storyclaw.com/agents";
+function registryUrl(filePath) {
+    const base = process.env.TALENTHUB_REGISTRY?.trim() || DEFAULT_REGISTRY;
+    return `${base.replace(/\/$/, "")}/${filePath}`;
+}
+export async function fetchCatalog() {
+    const url = registryUrl("catalog.json");
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch catalog: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+export async function fetchManifest(agentId) {
+    const url = registryUrl(`${agentId}/manifest.json`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Agent "${agentId}" not found in registry (${res.status})`);
+    }
+    return res.json();
+}
+export async function fetchAgentFile(agentId, filename) {
+    const url = registryUrl(`${agentId}/${filename}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${filename} for agent "${agentId}" (${res.status})`);
+    }
+    return res.text();
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveStateDir(): string;
+export declare function resolveConfigPath(): string;
+export declare function resolveWorkspaceDir(agentId: string): string;
+export declare function resolveTalentHubStatePath(): string;

package/dist/lib/paths.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function resolveHomeDir() {
+    return process.env.OPENCLAW_HOME?.trim() || os.homedir();
+}
+export function resolveStateDir() {
+    const override = process.env.OPENCLAW_STATE_DIR?.trim();
+    if (override) {
+        return path.resolve(override.replace(/^~/, resolveHomeDir()));
+    }
+    const home = resolveHomeDir();
+    const newDir = path.join(home, ".openclaw");
+    if (fs.existsSync(newDir))
+        return newDir;
+    const legacy = path.join(home, ".clawdbot");
+    if (fs.existsSync(legacy))
+        return legacy;
+    return newDir;
+}
+export function resolveConfigPath() {
+    const override = process.env.OPENCLAW_CONFIG_PATH?.trim();
+    if (override) {
+        return path.resolve(override.replace(/^~/, resolveHomeDir()));
+    }
+    const stateDir = resolveStateDir();
+    const candidates = ["openclaw.json", "clawdbot.json"];
+    for (const name of candidates) {
+        const p = path.join(stateDir, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return path.join(stateDir, "openclaw.json");
+}
+export function resolveWorkspaceDir(agentId) {
+    const stateDir = resolveStateDir();
+    if (agentId === "main") {
+        return process.env.OPENCLAW_WORKSPACE?.trim()
+            ? path.resolve(process.env.OPENCLAW_WORKSPACE.replace(/^~/, resolveHomeDir()))
+            : path.join(stateDir, "workspace");
+    }
+    return path.join(stateDir, `workspace-${agentId}`);
+}
+export function resolveTalentHubStatePath() {
+    return path.join(resolveStateDir(), "talenthub.json");
+}

package/dist/lib/registry.d.ts

@@ -0,0 +1,31 @@
+export type CatalogAgent = {
+    version: string;
+    name: string;
+    emoji: string;
+    category: string;
+    role: string;
+    tagline: string;
+    skillCount: number;
+};
+export type Catalog = {
+    catalogVersion: number;
+    updatedAt: string;
+    agents: Record<string, CatalogAgent>;
+};
+export type AgentManifest = {
+    id: string;
+    version: string;
+    name: string;
+    emoji: string;
+    model: string;
+    category: string;
+    role: string;
+    tagline: string;
+    description: string;
+    minOpenClawVersion: string;
+    skills: string[];
+    avatarUrl: string | null;
+    files: Record<string, string>;
+};
+export declare function fetchCatalog(): Promise<Catalog>;
+export declare function fetchManifest(agentId: string): Promise<AgentManifest>;

package/dist/lib/registry.js

@@ -0,0 +1,21 @@
+import { getRegistryBaseUrl } from "./auth.js";
+function apiUrl(path) {
+    const base = getRegistryBaseUrl().replace(/\/$/, "");
+    return `${base}/api/talent/registry${path}`;
+}
+export async function fetchCatalog() {
+    const url = apiUrl("/catalog");
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch catalog: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+export async function fetchManifest(agentId) {
+    const url = apiUrl(`/${agentId}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`Agent "${agentId}" not found in registry (${res.status})`);
+    }
+    return res.json();
+}

package/dist/lib/state.d.ts

@@ -0,0 +1,12 @@
+export type InstalledAgent = {
+    version: string;
+    installedAt: string;
+};
+export type TalentHubState = {
+    agents: Record<string, InstalledAgent>;
+    lastUpdateCheck?: string;
+};
+export declare function readState(): TalentHubState;
+export declare function writeState(state: TalentHubState): void;
+export declare function markInstalled(agentId: string, version: string): void;
+export declare function markUninstalled(agentId: string): void;

package/dist/lib/state.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import { resolveTalentHubStatePath } from "./paths.js";
+export function readState() {
+    const statePath = resolveTalentHubStatePath();
+    if (!fs.existsSync(statePath)) {
+        return { agents: {} };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+    catch {
+        return { agents: {} };
+    }
+}
+export function writeState(state) {
+    const statePath = resolveTalentHubStatePath();
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+export function markInstalled(agentId, version) {
+    const state = readState();
+    state.agents[agentId] = {
+        version,
+        installedAt: new Date().toISOString(),
+    };
+    writeState(state);
+}
+export function markUninstalled(agentId) {
+    const state = readState();
+    delete state.agents[agentId];
+    writeState(state);
+}

package/dist/lib/update-check.d.ts

@@ -0,0 +1,9 @@
+import { type Catalog } from "./registry.js";
+export type UpdateInfo = {
+    agentId: string;
+    currentVersion: string;
+    latestVersion: string;
+    name: string;
+};
+export declare function getCatalogCached(): Promise<Catalog>;
+export declare function checkUpdates(): Promise<UpdateInfo[]>;

package/dist/lib/update-check.js

@@ -0,0 +1,34 @@
+import { fetchCatalog } from "./registry.js";
+import { readState, writeState } from "./state.js";
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+export async function getCatalogCached() {
+    const state = readState();
+    const lastCheck = state.lastUpdateCheck ? new Date(state.lastUpdateCheck).getTime() : 0;
+    const now = Date.now();
+    if (now - lastCheck < CACHE_TTL_MS) {
+        // Within cache window; still fetch but don't worry about staleness
+    }
+    const catalog = await fetchCatalog();
+    state.lastUpdateCheck = new Date().toISOString();
+    writeState(state);
+    return catalog;
+}
+export async function checkUpdates() {
+    const state = readState();
+    const catalog = await getCatalogCached();
+    const updates = [];
+    for (const [agentId, installed] of Object.entries(state.agents)) {
+        const remote = catalog.agents[agentId];
+        if (!remote)
+            continue;
+        if (remote.version !== installed.version) {
+            updates.push({
+                agentId,
+                currentVersion: installed.version,
+                latestVersion: remote.version,
+                name: remote.name,
+            });
+        }
+    }
+    return updates;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@storyclaw/talenthub",
+  "version": "0.1.0",
+  "description": "CLI tool to manage StoryClaw AI agents",
+  "type": "module",
+  "bin": {
+    "talenthub": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/storyclaw-official/agents"
+  }
+}