@genrupt/cli 0.1.0 → 0.1.2

package/dist/doctor.js

@@ -0,0 +1,225 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { getValidConfig } from "./auth.js";
+import { CLI_VERSION } from "./constants.js";
+import { listRemoteMcpTools } from "./mcpClient.js";
+import { GENRUPT_SKILL_NAMES, computeInstalledSkillDigests, defaultTargetForAgent, detectAgent, getInstalledRuntimeManifestPath, readInstalledRuntimeManifest, } from "./skills.js";
+import { emitRuntimeTelemetry } from "./telemetry.js";
+import { CLI_PACKAGE_NAME, fetchLatestCliVersion, isVersionNewer } from "./version.js";
+function normalizeAgent(agent) {
+    const normalized = agent?.trim().toLowerCase();
+    if (!normalized)
+        return detectAgent();
+    if (normalized === "claude-code")
+        return "claude";
+    if (normalized === "claude" || normalized === "codex" || normalized === "cursor") {
+        return normalized;
+    }
+    throw new Error("--agent must be claude, codex, or cursor.");
+}
+function icon(status) {
+    if (status === "ok")
+        return "OK";
+    if (status === "warn")
+        return "WARN";
+    return "FAIL";
+}
+function buildSkillsCheck(params) {
+    const missingSkills = GENRUPT_SKILL_NAMES.filter((skillName) => !existsSync(path.join(params.targetRoot, skillName, "SKILL.md")));
+    if (missingSkills.length > 0) {
+        return {
+            label: "Skills",
+            status: "fail",
+            detail: `Missing ${missingSkills.length} skill(s) for ${params.agent}: ${missingSkills.join(", ")}`,
+            remediation: `Run: npx -y ${CLI_PACKAGE_NAME}@latest agent install --agent ${params.agent}`,
+        };
+    }
+    return {
+        label: "Skills",
+        status: "ok",
+        detail: `Installed for ${params.agent} at ${params.targetRoot}`,
+    };
+}
+async function buildRuntimeManifestCheck(targetRoot) {
+    const manifest = await readInstalledRuntimeManifest(targetRoot);
+    if (!manifest) {
+        return {
+            label: "Runtime manifest",
+            status: "warn",
+            detail: `No installed runtime manifest found at ${getInstalledRuntimeManifestPath(targetRoot)}`,
+            remediation: `Run: npx -y ${CLI_PACKAGE_NAME}@latest agent install`,
+        };
+    }
+    return {
+        label: "Runtime manifest",
+        status: "ok",
+        detail: `Skills ${manifest.version}, requires ${manifest.cliPackage} >= ${manifest.requiresCliVersion}`,
+    };
+}
+async function buildSkillIntegrityCheck(targetRoot) {
+    const manifest = await readInstalledRuntimeManifest(targetRoot);
+    if (!manifest?.installedSkills?.length) {
+        return {
+            label: "Skill integrity",
+            status: "warn",
+            detail: "No installed skill digests recorded.",
+            remediation: `Run: npx -y ${CLI_PACKAGE_NAME}@latest agent install`,
+        };
+    }
+    try {
+        const currentDigests = await computeInstalledSkillDigests(targetRoot);
+        const expectedByName = new Map(manifest.installedSkills.map((skill) => [skill.name, skill.digest]));
+        const changed = currentDigests.filter((skill) => expectedByName.get(skill.name) !== skill.digest);
+        if (changed.length > 0) {
+            return {
+                label: "Skill integrity",
+                status: "fail",
+                detail: `Changed skill file(s): ${changed.map((skill) => skill.name).join(", ")}`,
+                remediation: `Run: npx -y ${CLI_PACKAGE_NAME}@latest agent install`,
+            };
+        }
+        return {
+            label: "Skill integrity",
+            status: "ok",
+            detail: `Verified ${currentDigests.length} installed skill digest(s).`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            label: "Skill integrity",
+            status: "fail",
+            detail: message,
+            remediation: `Run: npx -y ${CLI_PACKAGE_NAME}@latest agent install`,
+        };
+    }
+}
+export async function runDoctor(options = {}) {
+    const startedAt = Date.now();
+    const checks = [];
+    const agent = normalizeAgent(options.agent);
+    const targetRoot = options.target?.trim() || defaultTargetForAgent(agent);
+    let latestCliVersion;
+    let staleCliDetected = false;
+    checks.push({
+        label: "CLI",
+        status: "ok",
+        detail: `${CLI_PACKAGE_NAME} ${CLI_VERSION}`,
+    });
+    try {
+        const latestVersion = await fetchLatestCliVersion();
+        latestCliVersion = latestVersion;
+        if (latestVersion && isVersionNewer(latestVersion, CLI_VERSION)) {
+            staleCliDetected = true;
+            checks.push({
+                label: "CLI update",
+                status: "warn",
+                detail: `Latest published CLI is ${latestVersion}; current is ${CLI_VERSION}`,
+                remediation: `Run: npm install -g ${CLI_PACKAGE_NAME}@latest`,
+            });
+        }
+        else {
+            checks.push({
+                label: "CLI update",
+                status: "ok",
+                detail: latestVersion
+                    ? `No newer published CLI found (published: ${latestVersion}, current: ${CLI_VERSION}).`
+                    : "No newer CLI found.",
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        checks.push({
+            label: "CLI update",
+            status: "warn",
+            detail: `Could not check npm registry: ${message}`,
+        });
+    }
+    let authenticated = false;
+    try {
+        const config = await getValidConfig();
+        authenticated = true;
+        checks.push({
+            label: "Auth",
+            status: "ok",
+            detail: `Authenticated for ${config.origin}`,
+        });
+    }
+    catch {
+        checks.push({
+            label: "Auth",
+            status: "fail",
+            detail: "Not authenticated.",
+            remediation: "Run: genrupt auth login",
+        });
+    }
+    if (authenticated) {
+        try {
+            const tools = await listRemoteMcpTools();
+            checks.push({
+                label: "Remote MCP",
+                status: "ok",
+                detail: `Listed ${tools.tools.length} tool(s).`,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            checks.push({
+                label: "Remote MCP",
+                status: "fail",
+                detail: message,
+                remediation: "Run: genrupt auth login, then retry genrupt doctor",
+            });
+        }
+    }
+    checks.push(buildSkillsCheck({ agent, targetRoot }));
+    checks.push(await buildRuntimeManifestCheck(targetRoot));
+    checks.push(await buildSkillIntegrityCheck(targetRoot));
+    const failed = checks.some((check) => check.status === "fail");
+    const warned = checks.some((check) => check.status === "warn");
+    if (options.json) {
+        console.log(JSON.stringify({ ok: !failed, warned, agent, targetRoot, checks }, null, 2));
+    }
+    else {
+        console.log();
+        console.log("Genrupt doctor");
+        console.log();
+        for (const check of checks) {
+            console.log(`[${icon(check.status)}] ${check.label}: ${check.detail}`);
+            if (check.remediation) {
+                console.log(`      ${check.remediation}`);
+            }
+        }
+    }
+    if (staleCliDetected && latestCliVersion) {
+        await emitRuntimeTelemetry({
+            eventType: "stale_cli_detected",
+            command: "doctor",
+            agent,
+            latestCliVersion,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+                source: "doctor",
+            },
+        });
+    }
+    if (failed) {
+        const failedChecks = checks.filter((check) => check.status === "fail");
+        const warnedChecks = checks.filter((check) => check.status === "warn");
+        await emitRuntimeTelemetry({
+            eventType: "doctor_failed",
+            command: "doctor",
+            agent,
+            latestCliVersion,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+                failedChecks: failedChecks.map((check) => check.label),
+                failedCount: failedChecks.length,
+                warnedChecks: warnedChecks.map((check) => check.label),
+                warnedCount: warnedChecks.length,
+            },
+        });
+        throw new Error("Genrupt doctor found failing checks.");
+    }
+}

package/dist/localMcpServer.js

@@ -3,11 +3,12 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { CLI_VERSION } from "./constants.js";
 import { listRemoteMcpTools, callRemoteMcpTool } from "./mcpClient.js";
-import { uploadProductReferenceImages } from "./upload.js";
+import { uploadProductReferenceImages, uploadReferenceMedia, } from "./upload.js";
+import { classifyCliError, emitRuntimeTelemetry } from "./telemetry.js";
 const LOCAL_UPLOAD_TOOL = {
     name: "upload_product_reference_images",
     title: "Upload local product reference images",
-    description: "Use when the user provides local image file paths from this computer and wants them uploaded to Genrupt as product reference assets. This local CLI MCP tool can read local files, uploads them through Genrupt's presigned upload flow, completes registration, and returns sourceAssetIds for create_product_reference_sheet. Supports JPEG, PNG, and WebP images up to 50 MB each.",
+    description: "Use when the user provides local image file or folder paths from this computer and needs ProductReferenceAsset sourceAssetIds for create_product_reference_sheet. For custom video reference images, videos, or audio, prefer upload_reference_media. This local CLI MCP tool can read local files/folders, uploads supported images through Genrupt's presigned upload flow, completes registration, and returns sourceAssetIds plus referenceImageUrls. Folder paths include JPEG, PNG, and WebP files directly inside the folder. Supports JPEG, PNG, and WebP images up to 50 MB each.",
     inputSchema: {
         type: "object",
         properties: {
@@ -15,7 +16,7 @@ const LOCAL_UPLOAD_TOOL = {
                 type: "array",
                 minItems: 1,
                 items: { type: "string", minLength: 1 },
-                description: "Absolute or working-directory-relative local image file paths.",
+                description: "Absolute or working-directory-relative local image file paths or folders containing images.",
             },
             asin: {
                 type: "string",
@@ -42,6 +43,35 @@ const LOCAL_UPLOAD_TOOL = {
         additionalProperties: false,
     },
 };
+const LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL = {
+    name: "upload_reference_media",
+    title: "Upload local reference media",
+    description: "Use when the user provides local image, video, audio, or folder paths from this computer for custom video reference inputs. This local CLI MCP tool can read local files/folders, upload supported media through Genrupt's presigned reference-asset flow, and return typed referenceImageUrls, referenceVideoUrls, and referenceAudioUrls for generate_video. Folder paths include supported files directly inside the folder. Supports JPEG, PNG, WebP, MP4, MOV, WebM, MP3, WAV, M4A, and OGG files up to 50 MB each. This does not create sourceAssetIds for Product Reference Sheets; use upload_product_reference_images for that.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            paths: {
+                type: "array",
+                minItems: 1,
+                items: { type: "string", minLength: 1 },
+                description: "Absolute or working-directory-relative local media file paths or folders containing supported media.",
+            },
+            mediaKind: {
+                type: "string",
+                enum: ["media", "image", "video", "audio"],
+                default: "media",
+                description: "Optional media filter. Use media to auto-detect supported image, video, and audio files.",
+            },
+            projectId: {
+                type: "string",
+                minLength: 1,
+                description: "Optional Genrupt project ID to scope uploaded reference media.",
+            },
+        },
+        required: ["paths"],
+        additionalProperties: false,
+    },
+};
 function buildToolResult(payload) {
     return {
         content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
@@ -75,11 +105,11 @@ function buildToolError(error) {
 }
 function normalizeStringArray(value) {
     if (!Array.isArray(value)) {
-        throw new Error("paths must be an array of image file paths.");
+        throw new Error("paths must be an array of local file or folder paths.");
     }
     const paths = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
     if (paths.length === 0) {
-        throw new Error("paths must include at least one image file path.");
+        throw new Error("paths must include at least one local file or folder path.");
     }
     return paths;
 }
@@ -97,6 +127,23 @@ async function handleLocalUploadTool(args) {
     });
     return buildToolResult(payload);
 }
+function normalizeMediaKind(value) {
+    if (value === undefined || value === null || value === "") {
+        return "media";
+    }
+    if (value === "media" || value === "image" || value === "video" || value === "audio") {
+        return value;
+    }
+    throw new Error("mediaKind must be media, image, video, or audio.");
+}
+async function handleLocalReferenceMediaUploadTool(args) {
+    const payload = await uploadReferenceMedia({
+        paths: normalizeStringArray(args.paths),
+        mode: normalizeMediaKind(args.mediaKind),
+        projectId: getOptionalString(args, "projectId"),
+    });
+    return buildToolResult(payload);
+}
 export async function serveLocalMcp() {
     const server = new Server({
         name: "genrupt-cli",
@@ -105,7 +152,7 @@ export async function serveLocalMcp() {
         capabilities: {
             tools: {},
         },
-        instructions: "Genrupt local bridge. Use upload_product_reference_images for local file paths, then use Genrupt remote MCP tools for market analysis, listing images, A+ content, product reference sheets, and video workflows.",
+        instructions: "Genrupt local bridge. Use upload_reference_media for local image/video/audio reference paths in custom video workflows. Use upload_product_reference_images when product reference sheet workflows need sourceAssetIds. Then use Genrupt remote MCP tools for market analysis, listing images, A+ content, product reference sheets, and video workflows.",
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         try {
@@ -113,14 +160,16 @@ export async function serveLocalMcp() {
             return {
                 tools: [
                     LOCAL_UPLOAD_TOOL,
-                    ...remote.tools.filter((tool) => tool.name !== LOCAL_UPLOAD_TOOL.name),
+                    LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL,
+                    ...remote.tools.filter((tool) => tool.name !== LOCAL_UPLOAD_TOOL.name &&
+                        tool.name !== LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL.name),
                 ],
             };
         }
         catch (error) {
             console.error(`[genrupt] Failed to list remote MCP tools: ${error instanceof Error ? error.message : String(error)}`);
             return {
-                tools: [LOCAL_UPLOAD_TOOL],
+                tools: [LOCAL_UPLOAD_TOOL, LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL],
             };
         }
     });
@@ -132,9 +181,25 @@ export async function serveLocalMcp() {
             if (request.params.name === LOCAL_UPLOAD_TOOL.name) {
                 return await handleLocalUploadTool(args);
             }
+            if (request.params.name === LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL.name) {
+                return await handleLocalReferenceMediaUploadTool(args);
+            }
             return await callRemoteMcpTool(request.params.name, args);
         }
         catch (error) {
+            if (request.params.name === LOCAL_UPLOAD_TOOL.name ||
+                request.params.name === LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL.name) {
+                await emitRuntimeTelemetry({
+                    eventType: "upload_failed",
+                    command: request.params.name,
+                    errorCode: classifyCliError(error, "LOCAL_MCP_UPLOAD_FAILED"),
+                    metadata: {
+                        uploadType: request.params.name === LOCAL_REFERENCE_MEDIA_UPLOAD_TOOL.name
+                            ? getOptionalString(args, "mediaKind") ?? "media"
+                            : "product_reference_images",
+                    },
+                });
+            }
             return buildToolError(error);
         }
     });

package/dist/skills.js

@@ -0,0 +1,219 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { CLI_VERSION, DEFAULT_ORIGIN } from "./constants.js";
+import { isVersionAtLeast } from "./version.js";
+export const GENRUPT_SKILL_NAMES = [
+    "genrupt-listing-video",
+    "genrupt-custom-video",
+    "genrupt-listing-images",
+    "genrupt-aplus-content",
+    "genrupt-product-variations",
+];
+const SKILL_FILES = [
+    "SKILL.md",
+    "agents/openai.yaml",
+    "references/local-reference-assets.md",
+    "assets/icon.svg",
+];
+const CURSOR_PLUGIN_FILES = [
+    ".cursor-plugin/plugin.json",
+    "VERSION",
+    "README.md",
+    "runtime.json",
+];
+function normalizeOrigin(origin) {
+    return (origin?.trim() || DEFAULT_ORIGIN).replace(/\/$/, "");
+}
+function normalizeAgent(agent) {
+    const normalized = agent?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "claude-code")
+        return "claude";
+    if (normalized === "claude" || normalized === "codex" || normalized === "cursor") {
+        return normalized;
+    }
+    throw new Error("--agent must be claude, codex, or cursor.");
+}
+export function detectAgent() {
+    const home = os.homedir();
+    if (process.env.CLAUDECODE || process.env.CLAUDE_CODE)
+        return "claude";
+    if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_SESSION_ID)
+        return "cursor";
+    if (process.env.CODEX_HOME || process.env.OPENAI_CODEX)
+        return "codex";
+    if (pathExistsSync(path.join(home, ".claude")))
+        return "claude";
+    if (pathExistsSync(path.join(home, ".codex")))
+        return "codex";
+    if (pathExistsSync(path.join(home, ".cursor")))
+        return "cursor";
+    return "claude";
+}
+function pathExistsSync(filePath) {
+    return existsSync(filePath);
+}
+export function defaultTargetForAgent(agent) {
+    const home = os.homedir();
+    if (agent === "claude")
+        return path.join(home, ".claude", "skills");
+    if (agent === "codex")
+        return path.join(home, ".codex", "skills");
+    return path.join(home, ".cursor", "plugins", "genrupt");
+}
+function targetRootForSkillInstall(params) {
+    return params.target?.trim() || defaultTargetForAgent(params.agent);
+}
+async function fetchText(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+async function downloadPublicFile(params) {
+    const relativePath = params.relativePath
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+    return fetchText(`${params.origin}/downloads/genrupt-skills/${relativePath}`);
+}
+function parseRuntimeManifest(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed.name !== "genrupt-agent-runtime" ||
+        typeof parsed.version !== "string" ||
+        typeof parsed.requiresCliVersion !== "string" ||
+        typeof parsed.cliPackage !== "string" ||
+        typeof parsed.cliBinary !== "string" ||
+        !Array.isArray(parsed.skills)) {
+        throw new Error("Invalid Genrupt runtime manifest.");
+    }
+    return {
+        name: parsed.name,
+        version: parsed.version,
+        requiresCliVersion: parsed.requiresCliVersion,
+        cliPackage: parsed.cliPackage,
+        cliBinary: parsed.cliBinary,
+        skills: parsed.skills.filter((skill) => typeof skill === "string"),
+        installedSkills: Array.isArray(parsed.installedSkills)
+            ? parsed.installedSkills.flatMap((skill) => {
+                if (skill &&
+                    typeof skill === "object" &&
+                    "name" in skill &&
+                    "digest" in skill &&
+                    typeof skill.name === "string" &&
+                    typeof skill.digest === "string") {
+                    return [{ name: skill.name, digest: skill.digest }];
+                }
+                return [];
+            })
+            : undefined,
+    };
+}
+export async function downloadRuntimeManifest(origin) {
+    return parseRuntimeManifest(await downloadPublicFile({
+        origin,
+        relativePath: "runtime.json",
+    }));
+}
+export function getInstalledRuntimeManifestPath(targetRoot) {
+    return path.join(targetRoot, ".genrupt-runtime.json");
+}
+export async function readInstalledRuntimeManifest(targetRoot) {
+    try {
+        const raw = await readFile(getInstalledRuntimeManifestPath(targetRoot), "utf8");
+        return parseRuntimeManifest(raw.replace(/^\uFEFF/, ""));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+async function computeInstalledSkillDigest(params) {
+    const hash = crypto.createHash("sha256");
+    for (const file of SKILL_FILES) {
+        const filePath = path.join(params.targetRoot, params.skillName, ...file.split("/"));
+        hash.update(file);
+        hash.update(await readFile(filePath));
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+export async function computeInstalledSkillDigests(targetRoot) {
+    return Promise.all(GENRUPT_SKILL_NAMES.map(async (skillName) => ({
+        name: skillName,
+        digest: await computeInstalledSkillDigest({ targetRoot, skillName }),
+    })));
+}
+async function writeInstalledRuntimeManifest(params) {
+    const installedSkills = await computeInstalledSkillDigests(params.targetRoot);
+    await writeFile(getInstalledRuntimeManifestPath(params.targetRoot), `${JSON.stringify({
+        ...params.runtime,
+        installedSkills,
+        agent: params.agent,
+        origin: params.origin,
+        installedCliVersion: CLI_VERSION,
+        installedAt: new Date().toISOString(),
+    }, null, 2)}\n`, "utf8");
+}
+function assertRuntimeSupported(runtime) {
+    if (isVersionAtLeast(CLI_VERSION, runtime.requiresCliVersion)) {
+        return;
+    }
+    throw new Error(`These Genrupt skills require ${runtime.cliPackage} >= ${runtime.requiresCliVersion}; installed CLI is ${CLI_VERSION}.\n` +
+        `Update with: npm install -g ${runtime.cliPackage}@latest\n` +
+        `Or run once with: npx -y ${runtime.cliPackage}@latest agent install`);
+}
+async function writeDownloadedFile(params) {
+    const contents = await downloadPublicFile({
+        origin: params.origin,
+        relativePath: params.relativePath,
+    });
+    await mkdir(path.dirname(params.targetPath), { recursive: true });
+    await writeFile(params.targetPath, contents, "utf8");
+}
+async function installSkillFolder(params) {
+    const skillTarget = path.join(params.targetRoot, params.skillName);
+    await rm(skillTarget, { recursive: true, force: true });
+    for (const file of SKILL_FILES) {
+        await writeDownloadedFile({
+            origin: params.origin,
+            relativePath: `${params.skillName}/${file}`,
+            targetPath: path.join(skillTarget, ...file.split("/")),
+        });
+    }
+}
+async function installCursorPluginShell(params) {
+    for (const file of CURSOR_PLUGIN_FILES) {
+        await writeDownloadedFile({
+            origin: params.origin,
+            relativePath: file,
+            targetPath: path.join(params.targetRoot, ...file.split("/")),
+        });
+    }
+}
+export async function installSkills(options = {}) {
+    const agent = normalizeAgent(options.agent) ?? detectAgent();
+    const targetRoot = targetRootForSkillInstall({ agent, target: options.target });
+    const origin = normalizeOrigin(options.origin);
+    const runtime = await downloadRuntimeManifest(origin);
+    if (!options.skipRuntimeCheck) {
+        assertRuntimeSupported(runtime);
+    }
+    await mkdir(targetRoot, { recursive: true });
+    if (agent === "cursor") {
+        await installCursorPluginShell({ origin, targetRoot });
+    }
+    for (const skillName of GENRUPT_SKILL_NAMES) {
+        await installSkillFolder({ origin, targetRoot, skillName });
+    }
+    await writeInstalledRuntimeManifest({ targetRoot, agent, origin, runtime });
+    console.log(`Installed ${GENRUPT_SKILL_NAMES.length} Genrupt skills for ${agent}.`);
+    console.log(`Runtime: ${runtime.version} (requires ${runtime.cliPackage} >= ${runtime.requiresCliVersion})`);
+    console.log(targetRoot);
+}