@dreamlogic-ai/cli 1.0.0

package/dist/commands/setup-mcp.js

@@ -0,0 +1,204 @@
+/**
+ * setup-mcp command — auto-configure MCP for AI agents
+ * D-11: Shows diff + confirmation before writing; supports --dry-run
+ * R1-02: execFileSync instead of execSync (no shell injection)
+ * R1-01: Config files written with 0o600 permissions
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { execFileSync } from "child_process";
+import { confirm } from "@inquirer/prompts";
+import { getServer, maskKey } from "../lib/config.js";
+import { ui } from "../lib/ui.js";
+import { requireAuth } from "./helpers.js";
+import chalk from "chalk";
+/** R1-01: Mask key in displayed config JSON */
+function maskConfigJson(config, key) {
+    return JSON.stringify(config, null, 2).replace(new RegExp(key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), "g"), maskKey(key));
+}
+/** Write config file with restrictive permissions (R1-01) */
+function writeConfigSafe(path, data) {
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, data, { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch { /* Windows fallback */ }
+}
+function getAgents(server, key) {
+    const isWin = platform() === "win32";
+    const home = homedir();
+    const claudeDesktopPath = isWin
+        ? join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json")
+        : join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return [
+        {
+            name: "Claude Desktop",
+            configPath: claudeDesktopPath,
+            detect: () => existsSync(claudeDesktopPath) || existsSync(join(claudeDesktopPath, "..")),
+            generate: () => ({
+                mcpServers: {
+                    "dreamlogic-skills": {
+                        url: `${server}/sse?api_key=${key}`,
+                    },
+                },
+            }),
+            apply: (newSection) => {
+                let existing = {};
+                if (existsSync(claudeDesktopPath)) {
+                    try {
+                        existing = JSON.parse(readFileSync(claudeDesktopPath, "utf-8"));
+                    }
+                    catch {
+                        // R2-07: Backup corrupted config instead of silently discarding
+                        const bakPath = claudeDesktopPath + ".bak";
+                        writeFileSync(bakPath, readFileSync(claudeDesktopPath));
+                        ui.warning(`Existing config has invalid JSON — backed up to ${bakPath}`);
+                    }
+                }
+                const merged = {
+                    ...existing,
+                    mcpServers: {
+                        ...(existing.mcpServers || {}),
+                        ...(newSection.mcpServers || {}),
+                    },
+                };
+                writeConfigSafe(claudeDesktopPath, JSON.stringify(merged, null, 2) + "\n");
+            },
+        },
+        {
+            name: "Claude CLI",
+            configPath: "(uses `claude mcp add` command)",
+            // R1-18: Platform-specific detection
+            detect: () => {
+                try {
+                    if (isWin) {
+                        execFileSync("where", ["claude"], { stdio: "ignore" });
+                    }
+                    else {
+                        execFileSync("sh", ["-c", "command -v claude"], { stdio: "ignore" });
+                    }
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            generate: () => ({
+                // R1-02: Store args as array, not interpolated string
+                args: ["mcp", "add", "dreamlogic-skills", "--url", `${server}/sse?api_key=${key}`],
+            }),
+            apply: (config) => {
+                // R1-02: execFileSync with arg array — no shell injection possible
+                execFileSync("claude", config.args, { stdio: "inherit" });
+            },
+        },
+        {
+            name: "Cursor",
+            configPath: join(home, ".cursor", "mcp.json"),
+            detect: () => existsSync(join(home, ".cursor")),
+            generate: () => ({
+                mcpServers: {
+                    "dreamlogic-skills": {
+                        url: `${server}/sse?api_key=${key}`,
+                    },
+                },
+            }),
+            apply: (newSection) => {
+                const path = join(home, ".cursor", "mcp.json");
+                let existing = {};
+                if (existsSync(path)) {
+                    try {
+                        existing = JSON.parse(readFileSync(path, "utf-8"));
+                    }
+                    catch {
+                        // R2-07: Backup corrupted config
+                        const bakPath = path + ".bak";
+                        writeFileSync(bakPath, readFileSync(path));
+                        ui.warning(`Existing config has invalid JSON — backed up to ${bakPath}`);
+                    }
+                }
+                const merged = {
+                    ...existing,
+                    mcpServers: {
+                        ...(existing.mcpServers || {}),
+                        ...(newSection.mcpServers || {}),
+                    },
+                };
+                writeConfigSafe(path, JSON.stringify(merged, null, 2) + "\n");
+            },
+        },
+    ];
+}
+export async function setupMcpCommand(opts) {
+    const apiKey = requireAuth();
+    if (!apiKey)
+        return;
+    const server = getServer();
+    const agents = getAgents(server, apiKey);
+    console.log();
+    ui.header("MCP Agent Configuration");
+    console.log();
+    // Detect installed agents
+    const detected = agents.filter((a) => a.detect());
+    const notDetected = agents.filter((a) => !a.detect());
+    if (detected.length > 0) {
+        ui.ok(`Detected ${detected.length} agent(s):`);
+        for (const a of detected)
+            ui.line(`  ${chalk.green("●")} ${a.name}`);
+    }
+    if (notDetected.length > 0) {
+        ui.line(`  ${ui.dim("Not detected: " + notDetected.map((a) => a.name).join(", "))}`);
+    }
+    if (detected.length === 0) {
+        ui.warning("No supported agents detected.");
+        ui.info("Supported agents: " + agents.map((a) => a.name).join(", "));
+        console.log();
+        ui.info("Manual MCP configuration:");
+        ui.line(`  Server URL: ${server}/sse`);
+        ui.line(`  API Key: ${maskKey(apiKey)}`);
+        return;
+    }
+    // R1-01: Warn about key in MCP URL (inherent to MCP SSE protocol)
+    ui.warning("MCP config will contain your API key in the URL (required by MCP protocol).");
+    ui.line(`  Config files are written with restricted permissions (owner-only).`);
+    // Configure each detected agent
+    for (const agent of detected) {
+        console.log();
+        ui.line(`${chalk.bold(agent.name)}:`);
+        const config = agent.generate(server, apiKey);
+        // D-11: Show what will be written (R1-01: mask key in display)
+        if (agent.name === "Claude CLI") {
+            const maskedCmd = `claude mcp add dreamlogic-skills --url "${server}/sse?api_key=${maskKey(apiKey)}"`;
+            ui.line(`  Command: ${chalk.cyan(maskedCmd)}`);
+        }
+        else {
+            ui.line(`  Config: ${agent.configPath}`);
+            ui.line(`  ${chalk.dim(maskConfigJson(config, apiKey).split("\n").join("\n  "))}`);
+        }
+        if (opts.dryRun) {
+            ui.info("(dry-run — no changes made)");
+            continue;
+        }
+        const ok = await confirm({
+            message: `Apply configuration for ${agent.name}?`,
+            default: true,
+        });
+        if (!ok) {
+            ui.info("Skipped.");
+            continue;
+        }
+        try {
+            agent.apply(config);
+            ui.ok(`${agent.name} configured`);
+            if (agent.name === "Claude Desktop") {
+                ui.info("Restart Claude Desktop to apply changes.");
+            }
+        }
+        catch (err) {
+            ui.err(`Failed: ${err.message}`);
+        }
+    }
+    ui.goodbye();
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,69 @@
+/**
+ * status command — show full status overview
+ */
+import { ApiClient } from "../lib/api-client.js";
+import { getApiKey, getServer, getInstallDir, loadInstalled, loadConfig, maskKey, } from "../lib/config.js";
+import { ui } from "../lib/ui.js";
+import chalk from "chalk";
+import { CLI_VERSION } from "../types.js";
+export async function statusCommand() {
+    const config = loadConfig();
+    const installed = loadInstalled();
+    console.log();
+    ui.header("Dreamlogic CLI Status");
+    console.log();
+    // Config
+    ui.table([
+        ["CLI Version", CLI_VERSION],
+        ["Server", config?.server || "(not configured)"],
+        ["API Key", config?.api_key ? maskKey(config.api_key) : chalk.red("(not set)")],
+        ["Install Dir", getInstallDir()],
+    ]);
+    // Server health — R2-05: use redirect:"error" like all other fetches
+    const server = getServer();
+    try {
+        const res = await fetch(`${server}/health`, {
+            headers: { "User-Agent": "dreamlogic-cli" },
+            redirect: "error",
+            signal: AbortSignal.timeout(5000),
+        });
+        const data = (await res.json());
+        // R2-09: Basic shape validation
+        if (typeof data?.status !== "string" || typeof data?.version !== "string") {
+            throw new Error("Invalid health response");
+        }
+        console.log();
+        ui.ok(`Server: ${data.status} (v${data.version})`);
+    }
+    catch {
+        console.log();
+        ui.warning("Server unreachable");
+    }
+    // Installed skills
+    const entries = Object.entries(installed);
+    console.log();
+    ui.line(`📦 Installed: ${entries.length} skill(s)`);
+    if (entries.length > 0) {
+        // Check for updates if authenticated
+        const apiKey = getApiKey();
+        let remoteSkills = [];
+        if (apiKey) {
+            try {
+                const client = new ApiClient(server, apiKey);
+                remoteSkills = await client.listSkills();
+            }
+            catch { /* skip remote check */ }
+        }
+        for (const [id, info] of entries) {
+            const remote = remoteSkills.find((s) => s.id === id);
+            // R2-06: Normalize version for comparison (strip leading 'v')
+            const normalizeVer = (v) => v.replace(/^v/, "");
+            const isUpToDate = !remote?.latest_version ||
+                normalizeVer(remote.latest_version) === normalizeVer(info.version);
+            const icon = isUpToDate ? chalk.green("✓") : chalk.yellow("⬆");
+            const update = !isUpToDate ? chalk.yellow(` → ${remote.latest_version}`) : "";
+            ui.line(`  ${icon} ${chalk.bold(id)} ${info.version}${update}`);
+        }
+    }
+    ui.goodbye();
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,3 @@
+export declare function updateCommand(opts: {
+    yes?: boolean;
+}): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,126 @@
+/**
+ * update command — check for and apply skill updates
+ */
+import { confirm, checkbox } from "@inquirer/prompts";
+import { ApiClient } from "../lib/api-client.js";
+import { getServer, loadInstalled } from "../lib/config.js";
+import { installSkill } from "../lib/installer.js";
+import { ui } from "../lib/ui.js";
+import { requireAuth } from "./helpers.js";
+import chalk from "chalk";
+export async function updateCommand(opts) {
+    const apiKey = requireAuth();
+    if (!apiKey)
+        return;
+    const installed = loadInstalled();
+    const installedIds = Object.keys(installed);
+    if (installedIds.length === 0) {
+        ui.info("No skills installed. Run: dreamlogic install");
+        return;
+    }
+    const client = new ApiClient(getServer(), apiKey);
+    const spinner = ui.spinner("Checking for updates...");
+    spinner.start();
+    let skills;
+    try {
+        skills = await client.listSkills();
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail("  Failed to check updates");
+        ui.err(err.message);
+        process.exitCode = 1;
+        return;
+    }
+    // Compare versions
+    const updates = [];
+    console.log();
+    for (const id of installedIds) {
+        const local = installed[id];
+        const remote = skills.find((s) => s.id === id);
+        if (!remote) {
+            ui.line(`  ${ui.warn("?")} ${id} — not found on server (removed?)`);
+            continue;
+        }
+        if (!remote.latest_version) {
+            ui.line(`  ${ui.dim("–")} ${remote.name} — no version info`);
+            continue;
+        }
+        // R1-16: Normalize version comparison (strip leading 'v')
+        const normalizeVer = (v) => v.replace(/^v/, "");
+        if (normalizeVer(local.version) === normalizeVer(remote.latest_version)) {
+            ui.line(`  ${chalk.green("✓")} ${remote.name} ${local.version} — up to date`);
+        }
+        else {
+            ui.line(`  ${chalk.yellow("⬆")} ${chalk.bold(remote.name)} ${local.version} → ${chalk.green(remote.latest_version)}`);
+            updates.push({
+                id: remote.id,
+                name: remote.name,
+                currentVersion: local.version,
+                latestVersion: remote.latest_version,
+                packageFile: remote.package_file || `${remote.id}-${remote.latest_version}.zip`,
+                sha256: remote.package_sha256,
+                size: remote.package_size,
+            });
+        }
+    }
+    if (updates.length === 0) {
+        console.log();
+        ui.ok("All skills are up to date! ✨");
+        return;
+    }
+    console.log();
+    ui.info(`${updates.length} update(s) available`);
+    // Select which to update
+    let selectedIds;
+    if (opts.yes) {
+        selectedIds = updates.map((u) => u.id);
+    }
+    else if (updates.length === 1) {
+        const ok = await confirm({
+            message: `Update ${updates[0].name} to ${updates[0].latestVersion}?`,
+            default: true,
+        });
+        selectedIds = ok ? [updates[0].id] : [];
+    }
+    else {
+        selectedIds = await checkbox({
+            message: "Select updates to apply:",
+            choices: updates.map((u) => ({
+                name: `${u.name} ${u.currentVersion} → ${u.latestVersion}${u.size ? ` (${ui.fileSize(u.size)})` : ""}`,
+                value: u.id,
+                checked: true,
+            })),
+        });
+    }
+    if (selectedIds.length === 0) {
+        ui.info("No updates selected.");
+        return;
+    }
+    // Apply updates
+    let successCount = 0;
+    for (const id of selectedIds) {
+        const u = updates.find((u) => u.id === id);
+        if (!u)
+            continue; // R1-19
+        console.log();
+        ui.header(`Updating ${u.name}`);
+        ui.line(`  ${u.currentVersion} → ${chalk.green(u.latestVersion)}`);
+        try {
+            await installSkill(client, u.id, u.packageFile, u.sha256, u.latestVersion);
+            ui.ok(`Updated to ${u.latestVersion}`);
+            successCount++;
+        }
+        catch (err) {
+            ui.err(`Failed: ${err.message}`);
+            ui.info(`Rollback with: dreamlogic rollback ${u.id}`);
+        }
+    }
+    console.log();
+    if (successCount === selectedIds.length) {
+        ui.ok(`All ${successCount} update(s) applied! 🎉`);
+    }
+    else {
+        ui.warning(`${successCount}/${selectedIds.length} updated. Check errors above.`);
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+/**
+ * Dreamlogic CLI — AI Skill Manager
+ * by Dreamlogic-ai · MAJORNINE
+ *
+ * Install, update and manage AI agent skills for your team.
+ */
+import { Command } from "commander";
+import { select } from "@inquirer/prompts";
+import { CLI_VERSION, CLI_NAME, CLI_AUTHOR } from "./types.js";
+import { ui } from "./lib/ui.js";
+import { getApiKey } from "./lib/config.js";
+// Commands
+import { loginCommand } from "./commands/login.js";
+import { logoutCommand } from "./commands/logout.js";
+import { catalogCommand } from "./commands/catalog.js";
+import { installCommand } from "./commands/install.js";
+import { updateCommand } from "./commands/update.js";
+import { listCommand } from "./commands/list.js";
+import { rollbackCommand } from "./commands/rollback.js";
+import { statusCommand } from "./commands/status.js";
+import { setupMcpCommand } from "./commands/setup-mcp.js";
+const program = new Command();
+program
+    .name("dreamlogic")
+    .description(`${CLI_NAME} — AI Skill Manager\n${CLI_AUTHOR}`)
+    .version(CLI_VERSION, "-v, --version");
+// ===== login =====
+program
+    .command("login")
+    .description("Authenticate with your Dreamlogic API key")
+    .option("-k, --key <key>", "API key (or enter interactively)")
+    .action((opts) => loginCommand(opts));
+// ===== logout =====
+program
+    .command("logout")
+    .description("Clear saved credentials")
+    .action(() => logoutCommand());
+// ===== catalog =====
+program
+    .command("catalog")
+    .description("List available skills from server")
+    .action(() => catalogCommand());
+// ===== install =====
+program
+    .command("install [skills...]")
+    .description("Install skills (interactive if no skill specified)")
+    .option("-y, --yes", "Skip confirmation prompts")
+    .option("--from-file <path>", "Install from local ZIP file (D-10)")
+    .action((skills, opts) => installCommand(skills, opts));
+// ===== update =====
+program
+    .command("update")
+    .description("Check for and apply skill updates")
+    .option("-y, --yes", "Auto-apply all updates")
+    .action((opts) => updateCommand(opts));
+// ===== list =====
+program
+    .command("list")
+    .alias("ls")
+    .description("List locally installed skills")
+    .action(() => listCommand());
+// ===== rollback =====
+program
+    .command("rollback <skill>")
+    .description("Rollback a skill to its previous version (D-13)")
+    .action((skill) => rollbackCommand(skill));
+// ===== status =====
+program
+    .command("status")
+    .description("Show full status overview")
+    .action(() => statusCommand());
+// ===== setup-mcp =====
+program
+    .command("setup-mcp")
+    .description("Auto-configure MCP for AI agents")
+    .option("--dry-run", "Show what would be configured without applying")
+    .action((opts) => setupMcpCommand(opts));
+// ===== Interactive mode (no command) =====
+program.action(async () => {
+    ui.banner();
+    const isLoggedIn = !!getApiKey();
+    if (!isLoggedIn) {
+        ui.info("First time? Let's get you set up!");
+        console.log();
+        await loginCommand({});
+        if (!getApiKey())
+            return; // login failed
+        console.log();
+    }
+    // Interactive menu
+    while (true) {
+        console.log();
+        const action = await select({
+            message: "What would you like to do?",
+            choices: [
+                { name: "📦 Install skills", value: "install" },
+                { name: "🔄 Check for updates", value: "update" },
+                { name: "📋 List installed skills", value: "list" },
+                { name: "⚙️  Configure MCP for Agent", value: "setup-mcp" },
+                { name: "📊 Status overview", value: "status" },
+                { name: "📚 Browse skill catalog", value: "catalog" },
+                { name: "🚪 Exit", value: "exit" },
+            ],
+        });
+        switch (action) {
+            case "install":
+                await installCommand([], {});
+                break;
+            case "update":
+                await updateCommand({});
+                break;
+            case "list":
+                listCommand();
+                break;
+            case "setup-mcp":
+                await setupMcpCommand({});
+                break;
+            case "status":
+                await statusCommand();
+                break;
+            case "catalog":
+                await catalogCommand();
+                break;
+            case "exit":
+                ui.goodbye();
+                return;
+        }
+    }
+});
+// Handle errors gracefully
+program.exitOverride();
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err) {
+            const code = err.code;
+            // Commander built-in exit (help, version)
+            if (code === "commander.helpDisplayed" || code === "commander.version") {
+                return;
+            }
+        }
+        // User cancelled (Ctrl+C on inquirer)
+        if (err && typeof err === "object" && "name" in err && err.name === "ExitPromptError") {
+            console.log();
+            ui.dim("  Cancelled.");
+            return;
+        }
+        ui.err(`Unexpected error: ${err.message}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/lib/api-client.d.ts

@@ -0,0 +1,25 @@
+import { type SkillInfo, type UserInfo } from "../types.js";
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    /** GET /api/me — verify key + get user info */
+    me(): Promise<UserInfo>;
+    /** GET /skills — list available skills with version info */
+    listSkills(): Promise<SkillInfo[]>;
+    /** GET /packages/:filename — download package as buffer (R1-11: size limited) */
+    downloadPackage(filename: string, onProgress?: (downloaded: number, total: number) => void): Promise<{
+        buffer: Buffer;
+        sha256: string;
+    }>;
+    /** GET /health — check server connectivity (R2-09: validated) */
+    health(): Promise<{
+        status: string;
+        version: string;
+    }>;
+}
+export declare class ApiError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}