@9000ai/cli 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+export interface RequestOptions {
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    path: string;
+    payload?: unknown;
+    baseUrl?: string;
+    apiKey?: string;
+    timeout?: number;
+}
+export declare function request(opts: RequestOptions): Promise<unknown>;
+export declare function printJson(data: unknown): void;

package/dist/client.js

@@ -0,0 +1,45 @@
+import { resolveBaseUrl, resolveApiKey } from "./config.js";
+export async function request(opts) {
+    const baseUrl = resolveBaseUrl(opts.baseUrl).replace(/\/+$/, "");
+    const apiKey = resolveApiKey(opts.apiKey);
+    const url = `${baseUrl}${opts.path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeout ?? 300_000);
+    const headers = {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json",
+    };
+    const fetchOpts = {
+        method: opts.method,
+        headers,
+        signal: controller.signal,
+    };
+    if (opts.payload !== undefined && opts.method !== "GET") {
+        fetchOpts.body = JSON.stringify(opts.payload);
+    }
+    try {
+        const res = await fetch(url, fetchOpts);
+        const data = await res.json();
+        if (!res.ok) {
+            const msg = data?.message ?? res.statusText;
+            console.error(`Error ${res.status}: ${msg}`);
+            process.exit(1);
+        }
+        return data;
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+            console.error("Error: request timed out");
+        }
+        else {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAuthCommands(parent: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,18 @@
+import { request, printJson } from "../client.js";
+export function registerAuthCommands(parent) {
+    const cmd = parent.command("auth").description("Authentication and permissions");
+    cmd
+        .command("whoami")
+        .description("Display current API key identity")
+        .action(async () => {
+        const data = await request({ method: "GET", path: "/api/v1/auth/me" });
+        printJson(data);
+    });
+    cmd
+        .command("capabilities")
+        .description("List capabilities available to current API key")
+        .action(async () => {
+        const data = await request({ method: "GET", path: "/api/v1/auth/capability-permissions" });
+        printJson(data);
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerConfigCommands(parent: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,30 @@
+import { loadConfig, saveConfig, resolveBaseUrl } from "../config.js";
+export function registerConfigCommands(parent) {
+    const cmd = parent.command("config").description("Manage CLI configuration");
+    cmd
+        .command("set")
+        .description("Set base URL and/or API key")
+        .option("--base-url <url>", "Hub service address")
+        .option("--api-key <key>", "API key for authentication")
+        .action((opts) => {
+        const patch = {};
+        if (opts.baseUrl)
+            patch.base_url = opts.baseUrl;
+        if (opts.apiKey)
+            patch.api_key = opts.apiKey;
+        if (Object.keys(patch).length === 0) {
+            console.error("Provide at least --base-url or --api-key");
+            process.exit(1);
+        }
+        saveConfig(patch);
+        console.log("Configuration saved.");
+    });
+    cmd
+        .command("show")
+        .description("Display current configuration")
+        .action(() => {
+        const cfg = loadConfig();
+        const baseUrl = resolveBaseUrl();
+        console.log(JSON.stringify({ ...cfg, resolved_base_url: baseUrl }, null, 2));
+    });
+}

package/dist/commands/feedback.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerFeedbackCommands(parent: Command): void;

package/dist/commands/feedback.js

@@ -0,0 +1,48 @@
+import { request, printJson } from "../client.js";
+import { loadJsonFile } from "../utils/format.js";
+export function registerFeedbackCommands(parent) {
+    const cmd = parent.command("feedback").description("Submit feedback to 9000AI platform");
+    cmd
+        .command("submit")
+        .description("Submit feedback (bug, feature, workflow suggestion)")
+        .option("--title <title>", "Feedback title")
+        .option("--content <content>", "Feedback details")
+        .option("--type <type>", "Category: workflow / bug / feature / other")
+        .option("--context-json <json>", "Additional context as JSON string")
+        .option("--json-file <path>", "Read feedback from JSON file")
+        .action(async (opts) => {
+        let payload;
+        if (opts.jsonFile) {
+            payload = loadJsonFile(opts.jsonFile);
+        }
+        else if (opts.title && opts.content) {
+            payload = { title: opts.title, content: opts.content };
+            if (opts.type)
+                payload.type = opts.type;
+            if (opts.contextJson)
+                payload.context = JSON.parse(opts.contextJson);
+        }
+        else {
+            console.error("Need --title + --content, or --json-file");
+            process.exit(1);
+        }
+        const data = await request({
+            method: "POST",
+            path: "/api/v1/feedback",
+            payload,
+        });
+        printJson(data);
+    });
+    cmd
+        .command("list")
+        .description("List my submitted feedback")
+        .option("--page <n>", "Page number", "1")
+        .option("--page-size <n>", "Items per page", "20")
+        .action(async (opts) => {
+        const data = await request({
+            method: "GET",
+            path: `/api/v1/feedback?page=${opts.page}&page_size=${opts.pageSize}`,
+        });
+        printJson(data);
+    });
+}

package/dist/commands/monitor.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerMonitorCommands(parent: Command): void;

package/dist/commands/monitor.js

@@ -0,0 +1,101 @@
+import { request, printJson } from "../client.js";
+import { loadJsonFile } from "../utils/format.js";
+export function registerMonitorCommands(parent) {
+    const cmd = parent.command("monitor").description("Douyin creator homepage monitoring");
+    cmd
+        .command("list-creators")
+        .description("List all monitoring targets")
+        .action(async () => {
+        const data = await request({ method: "GET", path: "/api/v1/douyin/monitor/creators" });
+        printJson(data);
+    });
+    cmd
+        .command("create-creator")
+        .description("Create new monitoring target")
+        .requiredOption("--json-file <path>", "JSON file with creator details")
+        .action(async (opts) => {
+        const payload = loadJsonFile(opts.jsonFile);
+        const data = await request({ method: "POST", path: "/api/v1/douyin/monitor/creators", payload });
+        printJson(data);
+    });
+    cmd
+        .command("get-creator")
+        .description("Get monitoring target details")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .action(async (opts) => {
+        const data = await request({ method: "GET", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}` });
+        printJson(data);
+    });
+    cmd
+        .command("update-creator")
+        .description("Update monitoring target")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .requiredOption("--json-file <path>", "JSON file with updated data")
+        .action(async (opts) => {
+        const payload = loadJsonFile(opts.jsonFile);
+        const data = await request({ method: "PATCH", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}`, payload });
+        printJson(data);
+    });
+    cmd
+        .command("delete-creator")
+        .description("Delete monitoring target")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .action(async (opts) => {
+        const data = await request({ method: "DELETE", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}` });
+        printJson(data);
+    });
+    cmd
+        .command("enable-creator")
+        .description("Enable monitoring for a creator")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .action(async (opts) => {
+        const data = await request({ method: "POST", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}/enable` });
+        printJson(data);
+    });
+    cmd
+        .command("disable-creator")
+        .description("Disable monitoring for a creator")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .action(async (opts) => {
+        const data = await request({ method: "POST", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}/disable` });
+        printJson(data);
+    });
+    cmd
+        .command("reset-creator")
+        .description("Reset creator monitoring status")
+        .requiredOption("--creator-id <id>", "Creator ID")
+        .action(async (opts) => {
+        const data = await request({ method: "POST", path: `/api/v1/douyin/monitor/creators/${opts.creatorId}/reset` });
+        printJson(data);
+    });
+    cmd
+        .command("submit")
+        .description("Submit homepage monitoring task")
+        .requiredOption("--json-file <path>", "JSON file with monitoring task details")
+        .action(async (opts) => {
+        const payload = loadJsonFile(opts.jsonFile);
+        const data = await request({ method: "POST", path: "/api/v1/douyin/monitor/run", payload });
+        printJson(data);
+    });
+    cmd
+        .command("list-runs")
+        .description("View execution history")
+        .option("--page <n>", "Page number", "1")
+        .option("--page-size <n>", "Items per page", "20")
+        .option("--status <status>", "Filter by status")
+        .action(async (opts) => {
+        const params = new URLSearchParams({ page: opts.page, page_size: opts.pageSize });
+        if (opts.status)
+            params.set("status", opts.status);
+        const data = await request({ method: "GET", path: `/api/v1/douyin/monitor/runs?${params}` });
+        printJson(data);
+    });
+    cmd
+        .command("run-detail")
+        .description("View single run details")
+        .requiredOption("--run-id <id>", "Run ID")
+        .action(async (opts) => {
+        const data = await request({ method: "GET", path: `/api/v1/douyin/monitor/runs/${opts.runId}` });
+        printJson(data);
+    });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSearchCommands(parent: Command): void;

package/dist/commands/search.js

@@ -0,0 +1,135 @@
+import { request, printJson } from "../client.js";
+import { writeJson, writeTsv, listOutputFiles, readOutputJson, timestampSlug } from "../output.js";
+export function registerSearchCommands(parent) {
+    const cmd = parent.command("search").description("Douyin topic discovery — trending boards and keyword search");
+    cmd
+        .command("hot")
+        .description("Fetch Douyin trending board")
+        .option("--type <type>", "Board type: hot|city|seeding|entertainment|society|challenge", "hot")
+        .option("--count <n>", "Number of items", "20")
+        .option("--city <city>", "City filter (only for type=city)")
+        .action(async (opts) => {
+        const params = new URLSearchParams({ type: opts.type, count: opts.count });
+        if (opts.city)
+            params.set("city", opts.city);
+        const data = await request({ method: "GET", path: `/api/v1/douyin/discovery/hot-board?${params}` });
+        const resp = data;
+        const inner = resp.data;
+        const items = (inner?.items ?? []);
+        const slug = timestampSlug();
+        writeJson("latest_hot.json", inner);
+        writeJson(`latest_hot_${slug}.json`, inner);
+        if (items.length > 0) {
+            writeTsv("latest_hot.tsv", items);
+            writeTsv(`latest_hot_${slug}.tsv`, items);
+        }
+        console.log(`Fetched ${items.length} items → output/latest_hot.json`);
+        printJson(inner);
+    });
+    cmd
+        .command("keyword")
+        .description("Search Douyin by keywords (async batch)")
+        .argument("<keywords...>", "One or more search keywords")
+        .option("--sort <n>", "Sort order", "0")
+        .option("--time <n>", "Time filter", "0")
+        .option("--content-type <n>", "Content type: 0=all 1=video 2=user", "0")
+        .option("--filter-duration <v>", "Duration filter", "")
+        .option("--min-likes <n>", "Minimum likes", "0")
+        .option("--min-comments <n>", "Minimum comments", "0")
+        .action(async (keywords, opts) => {
+        const payload = {
+            keywords,
+            count: 30,
+            sort: parseInt(opts.sort),
+            time: parseInt(opts.time),
+            content_type: parseInt(opts.contentType),
+            filter_duration: opts.filterDuration,
+            min_likes: parseInt(opts.minLikes),
+            min_comments: parseInt(opts.minComments),
+            max_concurrent: 3,
+        };
+        const data = await request({
+            method: "POST",
+            path: "/api/v1/douyin/discovery/search-videos/batch",
+            payload,
+        });
+        const resp = data;
+        const inner = resp.data;
+        console.log(`Batch submitted → batch_id: ${inner?.batch_id}`);
+        console.log(`Use: 9000ai search batch-result --batch-id ${inner?.batch_id}`);
+        printJson(inner);
+    });
+    cmd
+        .command("batch-result")
+        .description("Query async search batch results")
+        .requiredOption("--batch-id <id>", "Batch ID")
+        .action(async (opts) => {
+        const data = await request({
+            method: "GET",
+            path: `/api/v1/douyin/discovery/search-videos/batch/${opts.batchId}/results`,
+        });
+        const resp = data;
+        const inner = resp.data;
+        const items = (inner?.items ?? []);
+        if (items.length > 0) {
+            const slug = timestampSlug();
+            writeJson("latest_search.json", inner);
+            writeJson(`latest_search_${slug}.json`, inner);
+            writeTsv("latest_search.tsv", items);
+            writeTsv(`latest_search_${slug}.tsv`, items);
+            console.log(`${items.length} items → output/latest_search.json`);
+        }
+        printJson(inner);
+    });
+    cmd
+        .command("list-output")
+        .description("List result files in output directory")
+        .action(() => {
+        const files = listOutputFiles();
+        if (files.length === 0) {
+            console.log("No output files yet.");
+            return;
+        }
+        files.forEach((f) => console.log(f));
+    });
+    cmd
+        .command("show-result")
+        .description("Show single row from result file")
+        .option("--input <name>", "File name or alias (latest_search, latest_hot)", "latest_search")
+        .requiredOption("--row <n>", "Row number to display")
+        .action((opts) => {
+        const bundle = readOutputJson(opts.input);
+        const items = (bundle?.items ?? []);
+        const idx = parseInt(opts.row);
+        const item = items.find((i) => i.row_no === idx) ?? items[idx - 1];
+        if (!item) {
+            console.error(`Row ${opts.row} not found (total: ${items.length})`);
+            process.exit(1);
+        }
+        printJson(item);
+    });
+    cmd
+        .command("export-media")
+        .description("Extract media reference from result row")
+        .option("--input <name>", "File name or alias", "latest_search")
+        .requiredOption("--row <n>", "Row number to export")
+        .action((opts) => {
+        const bundle = readOutputJson(opts.input);
+        const items = (bundle?.items ?? []);
+        const idx = parseInt(opts.row);
+        const item = items.find((i) => i.row_no === idx) ?? items[idx - 1];
+        if (!item) {
+            console.error(`Row ${opts.row} not found`);
+            process.exit(1);
+        }
+        const media = {
+            video_url: item.video_url,
+            play_url: item.play_url,
+            download_url: item.download_url,
+            title: item.title ?? item.desc,
+            author_name: item.author_name,
+            duration: item.duration,
+        };
+        printJson(media);
+    });
+}

package/dist/commands/task.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerTaskCommands(parent: Command): void;

package/dist/commands/task.js

@@ -0,0 +1,20 @@
+import { request, printJson } from "../client.js";
+export function registerTaskCommands(parent) {
+    const cmd = parent.command("task").description("Query task status and results");
+    cmd
+        .command("status")
+        .description("Check task status")
+        .requiredOption("--task-id <id>", "Task ID")
+        .action(async (opts) => {
+        const data = await request({ method: "GET", path: `/api/v1/tasks/${opts.taskId}` });
+        printJson(data);
+    });
+    cmd
+        .command("results")
+        .description("Get task results")
+        .requiredOption("--task-id <id>", "Task ID")
+        .action(async (opts) => {
+        const data = await request({ method: "GET", path: `/api/v1/tasks/${opts.taskId}/results` });
+        printJson(data);
+    });
+}

package/dist/commands/transcribe.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerTranscribeCommands(parent: Command): void;

package/dist/commands/transcribe.js

@@ -0,0 +1,59 @@
+import { request, printJson } from "../client.js";
+import { loadJsonFile } from "../utils/format.js";
+export function registerTranscribeCommands(parent) {
+    const cmd = parent.command("transcribe").description("Video / audio transcription");
+    cmd
+        .command("submit")
+        .description("Submit batch video-to-text task")
+        .requiredOption("--json-file <path>", "JSON file with video task details")
+        .action(async (opts) => {
+        const payload = loadJsonFile(opts.jsonFile);
+        const data = await request({
+            method: "POST",
+            path: "/api/v1/media/batch-video-to-text",
+            payload,
+        });
+        printJson(data);
+    });
+    cmd
+        .command("text")
+        .description("Extract transcription text from completed task")
+        .requiredOption("--task-id <id>", "Task ID")
+        .action(async (opts) => {
+        const taskData = await request({ method: "GET", path: `/api/v1/tasks/${opts.taskId}` });
+        const inner = taskData.data;
+        if (!inner || inner.status !== "SUCCESS") {
+            console.log(`Task status: ${inner?.status ?? "unknown"}`);
+            if (inner?.status !== "SUCCESS") {
+                printJson(inner);
+                return;
+            }
+        }
+        const output = (typeof inner.output === "string" ? JSON.parse(inner.output) : inner.output);
+        const jsonUrl = output?.json_url;
+        if (!jsonUrl) {
+            console.error("No json_url in task output");
+            printJson(inner);
+            return;
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 60_000);
+        try {
+            const res = await fetch(jsonUrl, { signal: controller.signal });
+            const transcript = await res.json();
+            const text = transcript.text ?? "";
+            const sentences = (transcript.timecodes?.sentences ?? []);
+            printJson({
+                task_id: opts.taskId,
+                text_field: "text",
+                sentence_field: "timecodes.sentences[*].text",
+                text,
+                sentence_count: sentences.length,
+                duration_ms: transcript.duration_ms,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface AppConfig {
+    base_url?: string;
+    api_key?: string;
+}
+export declare function loadConfig(): AppConfig;
+export declare function saveConfig(patch: Partial<AppConfig>): void;
+export declare function resolveBaseUrl(override?: string): string;
+export declare function resolveApiKey(override?: string): string;

package/dist/config.js

@@ -0,0 +1,37 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".9000ai");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(patch) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    const current = loadConfig();
+    const merged = { ...current, ...patch };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf-8");
+}
+export function resolveBaseUrl(override) {
+    return (override ||
+        process.env["9000AI_BASE_URL"] ||
+        loadConfig().base_url ||
+        "http://127.0.0.1:8025");
+}
+export function resolveApiKey(override) {
+    const key = override ||
+        process.env["9000AI_API_KEY"] ||
+        loadConfig().api_key;
+    if (!key) {
+        console.error("Error: API key not configured. Run: 9000ai config set --api-key <key>");
+        process.exit(1);
+    }
+    return key;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerConfigCommands } from "./commands/config.js";
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerSearchCommands } from "./commands/search.js";
+import { registerMonitorCommands } from "./commands/monitor.js";
+import { registerTranscribeCommands } from "./commands/transcribe.js";
+import { registerTaskCommands } from "./commands/task.js";
+import { registerFeedbackCommands } from "./commands/feedback.js";
+const program = new Command();
+program
+    .name("9000ai")
+    .description("9000AI Toolbox CLI — unified interface for 9000AI platform")
+    .version("0.1.0");
+registerConfigCommands(program);
+registerAuthCommands(program);
+registerSearchCommands(program);
+registerMonitorCommands(program);
+registerTranscribeCommands(program);
+registerTaskCommands(program);
+registerFeedbackCommands(program);
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/output.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureOutputDir(): string;
+export declare function writeJson(filename: string, data: unknown): string;
+export declare function writeTsv(filename: string, rows: Record<string, unknown>[]): string;
+export declare function listOutputFiles(): string[];
+export declare function readOutputJson(nameOrPath: string): unknown;
+export declare function timestampSlug(): string;

package/dist/output.js

@@ -0,0 +1,49 @@
+import { mkdirSync, writeFileSync, readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+const OUTPUT_DIR = resolve("output");
+export function ensureOutputDir() {
+    mkdirSync(OUTPUT_DIR, { recursive: true });
+    return OUTPUT_DIR;
+}
+export function writeJson(filename, data) {
+    const dir = ensureOutputDir();
+    const filepath = join(dir, filename);
+    writeFileSync(filepath, JSON.stringify(data, null, 2), "utf-8");
+    return filepath;
+}
+export function writeTsv(filename, rows) {
+    if (rows.length === 0)
+        return "";
+    const dir = ensureOutputDir();
+    const filepath = join(dir, filename);
+    const keys = Object.keys(rows[0]);
+    const header = keys.join("\t");
+    const lines = rows.map((row) => keys.map((k) => String(row[k] ?? "")).join("\t"));
+    writeFileSync(filepath, [header, ...lines].join("\n"), "utf-8");
+    return filepath;
+}
+export function listOutputFiles() {
+    if (!existsSync(OUTPUT_DIR))
+        return [];
+    return readdirSync(OUTPUT_DIR).sort();
+}
+export function readOutputJson(nameOrPath) {
+    const aliases = {
+        latest_hot: "latest_hot.json",
+        latest_search: "latest_search.json",
+    };
+    const filename = aliases[nameOrPath] ?? nameOrPath;
+    const filepath = filename.includes("/") || filename.includes("\\")
+        ? resolve(filename)
+        : join(OUTPUT_DIR, filename);
+    if (!existsSync(filepath)) {
+        console.error(`File not found: ${filepath}`);
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync(filepath, "utf-8"));
+}
+export function timestampSlug() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}

package/dist/postinstall.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * postinstall: copy bundled skills to ~/.9000ai/skills/
+ */
+export {};

package/dist/postinstall.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * postinstall: copy bundled skills to ~/.9000ai/skills/
+ */
+import { existsSync, mkdirSync, cpSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const src = join(__dirname, "..", "skills");
+const dest = join(homedir(), ".9000ai", "skills");
+if (!existsSync(src)) {
+    process.exit(0);
+}
+mkdirSync(dest, { recursive: true });
+cpSync(src, dest, { recursive: true, force: true });
+console.log(`9000AI skills installed → ${dest}`);