@genrupt/cli 0.1.0 → 0.1.3

package/dist/telemetry.js

@@ -0,0 +1,156 @@
+import { CLI_VERSION, DEFAULT_ORIGIN } from "./constants.js";
+import { readConfig } from "./config.js";
+const TELEMETRY_TIMEOUT_MS = 1500;
+const ACCESS_TOKEN_SKEW_MS = 5000;
+function telemetryDisabled() {
+    const value = process.env.GENRUPT_DISABLE_TELEMETRY?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes";
+}
+function normalizeOrigin(origin) {
+    return (origin?.trim() || DEFAULT_ORIGIN).replace(/\/$/, "");
+}
+function isTokenFresh(expiresAt) {
+    const expiresAtMs = expiresAt ? new Date(expiresAt).getTime() : Number.NaN;
+    return Number.isFinite(expiresAtMs) && expiresAtMs > Date.now() + ACCESS_TOKEN_SKEW_MS;
+}
+async function readTelemetryConfig(originOverride) {
+    try {
+        const config = await readConfig();
+        return {
+            origin: normalizeOrigin(originOverride ?? config?.origin),
+            accessToken: config && isTokenFresh(config.accessTokenExpiresAt) ? config.accessToken : undefined,
+        };
+    }
+    catch {
+        return {
+            origin: normalizeOrigin(originOverride),
+        };
+    }
+}
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent?.trim();
+    if (userAgent) {
+        return userAgent.split(/\s+/)[0]?.slice(0, 160);
+    }
+    const execPath = process.env.npm_execpath?.toLowerCase();
+    if (execPath?.includes("pnpm"))
+        return "pnpm";
+    if (execPath?.includes("yarn"))
+        return "yarn";
+    if (execPath?.includes("npm"))
+        return "npm";
+    return undefined;
+}
+function detectInstallMethod() {
+    const configured = process.env.GENRUPT_CLI_INSTALL_METHOD?.trim();
+    if (configured)
+        return configured.slice(0, 80);
+    const userAgent = process.env.npm_config_user_agent?.toLowerCase() ?? "";
+    if (userAgent.includes("pnpm"))
+        return "pnpm";
+    if (userAgent.includes("yarn"))
+        return "yarn";
+    if (userAgent.includes("npm"))
+        return "npm";
+    return undefined;
+}
+function sanitizeMetadataString(value) {
+    const trimmed = value.trim().replace(/\s+/g, " ").slice(0, 240);
+    if (!trimmed)
+        return undefined;
+    if (/https?:\/\//i.test(trimmed) || /[\\/]/.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+function sanitizeMetadataValue(value) {
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === "string")
+        return sanitizeMetadataString(value);
+    if (Array.isArray(value)) {
+        const sanitized = value
+            .slice(0, 16)
+            .map((entry) => sanitizeMetadataValue(entry))
+            .filter((entry) => entry !== undefined);
+        return sanitized.length > 0 ? sanitized : undefined;
+    }
+    return undefined;
+}
+function sanitizeMetadata(metadata) {
+    if (!metadata)
+        return undefined;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metadata).slice(0, 24)) {
+        const safeKey = key.trim().replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 64);
+        if (!safeKey)
+            continue;
+        const safeValue = sanitizeMetadataValue(value);
+        if (safeValue !== undefined) {
+            sanitized[safeKey] = safeValue;
+        }
+    }
+    return Object.keys(sanitized).length > 0 ? sanitized : undefined;
+}
+export function classifyCliError(error, fallback = "COMMAND_FAILED") {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/not authenticated|authorization|auth|login/i.test(message))
+        return "AUTH_REQUIRED";
+    if (/subscription/i.test(message))
+        return "SUBSCRIPTION_REQUIRED";
+    if (/unsupported|file type|extension/i.test(message))
+        return "UNSUPPORTED_FILE_TYPE";
+    if (/npm install -g|globally|global genrupt cli/i.test(message)) {
+        return "GLOBAL_CLI_INSTALL_FAILED";
+    }
+    if (/network|fetch|enotfound|econn|etimedout|timeout/i.test(message))
+        return "NETWORK_FAILED";
+    if (/missing|required|invalid/i.test(message))
+        return "INVALID_INPUT";
+    return fallback;
+}
+export async function emitRuntimeTelemetry(payload, options = {}) {
+    if (telemetryDisabled())
+        return;
+    const config = await readTelemetryConfig(options.origin);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+    try {
+        const headers = {
+            "content-type": "application/json",
+            "user-agent": `genrupt-cli/${CLI_VERSION}`,
+        };
+        if (config.accessToken) {
+            headers.authorization = `Bearer ${config.accessToken}`;
+        }
+        await fetch(`${config.origin}/api/agent/runtime/telemetry`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                eventType: payload.eventType,
+                cliVersion: CLI_VERSION,
+                latestCliVersion: payload.latestCliVersion,
+                runtimeVersion: payload.runtimeVersion,
+                requiredCliVersion: payload.requiredCliVersion,
+                agent: payload.agent,
+                command: payload.command,
+                os: process.platform,
+                arch: process.arch,
+                nodeVersion: process.version,
+                packageManager: detectPackageManager(),
+                installMethod: payload.installMethod ?? detectInstallMethod(),
+                errorCode: payload.errorCode,
+                durationMs: payload.durationMs,
+                metadata: sanitizeMetadata(payload.metadata),
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        // Telemetry must never block or change CLI behavior.
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/updateCheck.js

@@ -0,0 +1,77 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { CLI_VERSION } from "./constants.js";
+import { getConfigDir } from "./config.js";
+import { emitRuntimeTelemetry } from "./telemetry.js";
+import { CLI_PACKAGE_NAME, fetchLatestCliVersion, isVersionNewer } from "./version.js";
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+function getUpdateCheckPath() {
+    return path.join(getConfigDir(), "update-check.json");
+}
+async function readUpdateCheckCache() {
+    try {
+        const parsed = JSON.parse(await readFile(getUpdateCheckPath(), "utf8"));
+        return {
+            checkedAt: typeof parsed.checkedAt === "string" ? parsed.checkedAt : "",
+            latestVersion: typeof parsed.latestVersion === "string" ? parsed.latestVersion : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeUpdateCheckCache(cache) {
+    try {
+        await mkdir(getConfigDir(), { recursive: true });
+        await writeFile(getUpdateCheckPath(), `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+    }
+    catch {
+        // Update checks must never block normal CLI usage.
+    }
+}
+function shouldUseCachedCheck(cache) {
+    if (!cache?.checkedAt)
+        return false;
+    const checkedAtMs = new Date(cache.checkedAt).getTime();
+    return Number.isFinite(checkedAtMs) && Date.now() - checkedAtMs < UPDATE_CHECK_INTERVAL_MS;
+}
+function buildUpdateMessage(latestVersion) {
+    return [
+        "",
+        `A newer Genrupt CLI is available: ${latestVersion} (installed: ${CLI_VERSION}).`,
+        `Update: npm install -g ${CLI_PACKAGE_NAME}@latest`,
+        `One-time latest run: npx -y ${CLI_PACKAGE_NAME}@latest agent install`,
+    ].join("\n");
+}
+export async function maybeWarnAboutCliUpdate() {
+    const cached = await readUpdateCheckCache();
+    if (shouldUseCachedCheck(cached)) {
+        if (cached?.latestVersion && isVersionNewer(cached.latestVersion, CLI_VERSION)) {
+            console.warn(buildUpdateMessage(cached.latestVersion));
+        }
+        return;
+    }
+    try {
+        const latestVersion = await fetchLatestCliVersion();
+        await writeUpdateCheckCache({
+            checkedAt: new Date().toISOString(),
+            latestVersion,
+        });
+        if (latestVersion && isVersionNewer(latestVersion, CLI_VERSION)) {
+            console.warn(buildUpdateMessage(latestVersion));
+            await emitRuntimeTelemetry({
+                eventType: "stale_cli_detected",
+                command: "update_check",
+                latestCliVersion: latestVersion,
+                metadata: {
+                    source: "daily_update_check",
+                },
+            });
+        }
+    }
+    catch {
+        await writeUpdateCheckCache({
+            checkedAt: new Date().toISOString(),
+        });
+    }
+}

package/dist/upload.js

@@ -1,20 +1,23 @@
-import { readFile, stat } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { assertSuccessfulToolPayload, executeRemoteCapability } from "./mcpClient.js";
 const MAX_PRODUCT_REFERENCE_BYTES = 50 * 1024 * 1024;
-function detectContentType(filePath) {
-    const extension = path.extname(filePath).toLowerCase();
-    if (extension === ".jpg" || extension === ".jpeg") {
-        return "image/jpeg";
-    }
-    if (extension === ".png") {
-        return "image/png";
-    }
-    if (extension === ".webp") {
-        return "image/webp";
-    }
-    throw new Error(`Unsupported image type for ${filePath}. Use JPEG, PNG, or WebP.`);
-}
+const MAX_REFERENCE_MEDIA_BYTES = 50 * 1024 * 1024;
+const MEDIA_BY_EXTENSION = new Map([
+    [".jpg", { kind: "image", contentType: "image/jpeg", fileExtension: ".jpg" }],
+    [".jpeg", { kind: "image", contentType: "image/jpeg", fileExtension: ".jpg" }],
+    [".png", { kind: "image", contentType: "image/png", fileExtension: ".png" }],
+    [".webp", { kind: "image", contentType: "image/webp", fileExtension: ".webp" }],
+    [".mp4", { kind: "video", contentType: "video/mp4", fileExtension: ".mp4" }],
+    [".mov", { kind: "video", contentType: "video/quicktime", fileExtension: ".mov" }],
+    [".webm", { kind: "video", contentType: "video/webm", fileExtension: ".webm" }],
+    [".mp3", { kind: "audio", contentType: "audio/mpeg", fileExtension: ".mp3" }],
+    [".wav", { kind: "audio", contentType: "audio/wav", fileExtension: ".wav" }],
+    [".m4a", { kind: "audio", contentType: "audio/mp4", fileExtension: ".m4a" }],
+    [".ogg", { kind: "audio", contentType: "audio/ogg", fileExtension: ".ogg" }],
+]);
+const SUPPORTED_IMAGE_LABEL = "JPEG, PNG, or WebP";
+const SUPPORTED_MEDIA_LABEL = "JPEG, PNG, WebP, MP4, MOV, WebM, MP3, WAV, M4A, or OGG";
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -44,6 +47,70 @@ function requireCompleteUploadPayload(payload) {
     }
     return record;
 }
+function allowedKindsForMode(mode = "media") {
+    if (mode === "media") {
+        return new Set(["image", "video", "audio"]);
+    }
+    return new Set([mode]);
+}
+function describeAllowedKinds(allowedKinds) {
+    if (allowedKinds.size === 1 && allowedKinds.has("image"))
+        return SUPPORTED_IMAGE_LABEL;
+    if (allowedKinds.size === 1 && allowedKinds.has("video"))
+        return "MP4, MOV, or WebM";
+    if (allowedKinds.size === 1 && allowedKinds.has("audio"))
+        return "MP3, WAV, M4A, or OGG";
+    return SUPPORTED_MEDIA_LABEL;
+}
+function detectReferenceMedia(filePath) {
+    const metadata = MEDIA_BY_EXTENSION.get(path.extname(filePath).toLowerCase());
+    if (!metadata) {
+        throw new Error(`Unsupported file type for ${filePath}. Use ${SUPPORTED_MEDIA_LABEL}.`);
+    }
+    return metadata;
+}
+function isSupportedMediaPath(filePath, allowedKinds) {
+    const metadata = MEDIA_BY_EXTENSION.get(path.extname(filePath).toLowerCase());
+    return Boolean(metadata && allowedKinds.has(metadata.kind));
+}
+async function expandMediaInputPath(inputPath, allowedKinds) {
+    const resolvedPath = path.resolve(inputPath);
+    const fileStat = await stat(resolvedPath);
+    if (fileStat.isFile()) {
+        const metadata = detectReferenceMedia(resolvedPath);
+        if (!allowedKinds.has(metadata.kind)) {
+            throw new Error(`${inputPath} is ${metadata.kind} media. This upload command accepts ${describeAllowedKinds(allowedKinds)}.`);
+        }
+        return [resolvedPath];
+    }
+    if (fileStat.isDirectory()) {
+        const entries = await readdir(resolvedPath, { withFileTypes: true });
+        const mediaPaths = entries
+            .filter((entry) => entry.isFile() && isSupportedMediaPath(entry.name, allowedKinds))
+            .map((entry) => path.join(resolvedPath, entry.name))
+            .sort((left, right) => left.localeCompare(right));
+        if (mediaPaths.length === 0) {
+            throw new Error(`${inputPath} does not contain supported ${describeAllowedKinds(allowedKinds)} files.`);
+        }
+        return mediaPaths;
+    }
+    throw new Error(`${inputPath} is not a file or folder.`);
+}
+async function expandMediaInputPaths(inputPaths, mode) {
+    const allowedKinds = allowedKindsForMode(mode);
+    const expandedPaths = [];
+    const seen = new Set();
+    for (const inputPath of inputPaths) {
+        const paths = await expandMediaInputPath(inputPath, allowedKinds);
+        for (const filePath of paths) {
+            if (seen.has(filePath))
+                continue;
+            seen.add(filePath);
+            expandedPaths.push(filePath);
+        }
+    }
+    return expandedPaths;
+}
 async function uploadBytes(params) {
     const body = new Blob([new Uint8Array(params.bytes)]);
     const response = await fetch(params.uploadUrl, {
@@ -56,67 +123,137 @@ async function uploadBytes(params) {
         throw new Error(`Storage upload failed with HTTP ${response.status}${body ? `: ${body.slice(0, 500)}` : ""}`);
     }
 }
-export async function uploadProductReferenceImages(options) {
-    if (options.paths.length === 0) {
-        throw new Error("At least one image path is required.");
+async function uploadProductReferenceImageFile(filePath, options) {
+    const fileStat = await stat(filePath);
+    if (!fileStat.isFile()) {
+        throw new Error(`${filePath} is not a file.`);
     }
-    const uploads = [];
-    for (const filePath of options.paths) {
-        const fileStat = await stat(filePath);
-        if (!fileStat.isFile()) {
-            throw new Error(`${filePath} is not a file.`);
-        }
-        if (fileStat.size > MAX_PRODUCT_REFERENCE_BYTES) {
-            throw new Error(`${filePath} is larger than 50 MB.`);
-        }
-        const fileName = path.basename(filePath);
-        const contentType = detectContentType(filePath);
-        const createResult = await executeRemoteCapability("create_product_reference_upload", {
-            fileName,
-            contentType,
-            byteLength: fileStat.size,
-            ...(options.asin ? { asin: options.asin } : {}),
-            ...(options.projectId ? { projectId: options.projectId } : {}),
-            ...(options.productProfileId ? { productProfileId: options.productProfileId } : {}),
-            ...(options.domain ? { domain: options.domain } : {}),
-        });
-        const createPayload = requireCreateUploadPayload(assertSuccessfulToolPayload(createResult));
-        const bytes = await readFile(filePath);
-        await uploadBytes({
-            uploadUrl: createPayload.uploadUrl,
-            method: createPayload.method ?? "PUT",
-            headers: createPayload.headers ?? { "Content-Type": contentType },
-            bytes,
-        });
-        const completeResult = await executeRemoteCapability("complete_product_reference_upload", {
-            objectKey: createPayload.objectKey,
-            assetUrl: createPayload.assetUrl,
-            contentType,
-            byteLength: fileStat.size,
-            fileName,
-            ...(options.asin ? { asin: options.asin } : {}),
-            ...(options.projectId ? { projectId: options.projectId } : {}),
-            ...(options.productProfileId ? { productProfileId: options.productProfileId } : {}),
-            ...(options.domain ? { domain: options.domain } : {}),
-        });
-        const completePayload = requireCompleteUploadPayload(assertSuccessfulToolPayload(completeResult));
-        uploads.push({
-            path: filePath,
-            fileName,
-            objectKey: createPayload.objectKey,
-            assetUrl: createPayload.assetUrl,
-            assetId: completePayload.asset?.id ?? null,
-            imageUrl: completePayload.asset?.imageUrl ?? createPayload.assetUrl,
-            contentType,
-            byteLength: fileStat.size,
-            alreadyCompleted: completePayload.alreadyCompleted ?? false,
-        });
+    if (fileStat.size > MAX_PRODUCT_REFERENCE_BYTES) {
+        throw new Error(`${filePath} is larger than 50 MB.`);
+    }
+    const fileName = path.basename(filePath);
+    const metadata = detectReferenceMedia(filePath);
+    if (metadata.kind !== "image") {
+        throw new Error(`Product reference uploads require ${SUPPORTED_IMAGE_LABEL} images.`);
     }
+    const createResult = await executeRemoteCapability("create_product_reference_upload", {
+        fileName,
+        contentType: metadata.contentType,
+        byteLength: fileStat.size,
+        ...(options.asin ? { asin: options.asin } : {}),
+        ...(options.projectId ? { projectId: options.projectId } : {}),
+        ...(options.productProfileId ? { productProfileId: options.productProfileId } : {}),
+        ...(options.domain ? { domain: options.domain } : {}),
+    });
+    const createPayload = requireCreateUploadPayload(assertSuccessfulToolPayload(createResult));
+    const bytes = await readFile(filePath);
+    await uploadBytes({
+        uploadUrl: createPayload.uploadUrl,
+        method: createPayload.method ?? "PUT",
+        headers: createPayload.headers ?? { "Content-Type": metadata.contentType },
+        bytes,
+    });
+    const completeResult = await executeRemoteCapability("complete_product_reference_upload", {
+        objectKey: createPayload.objectKey,
+        assetUrl: createPayload.assetUrl,
+        contentType: metadata.contentType,
+        byteLength: fileStat.size,
+        fileName,
+        ...(options.asin ? { asin: options.asin } : {}),
+        ...(options.projectId ? { projectId: options.projectId } : {}),
+        ...(options.productProfileId ? { productProfileId: options.productProfileId } : {}),
+        ...(options.domain ? { domain: options.domain } : {}),
+    });
+    const completePayload = requireCompleteUploadPayload(assertSuccessfulToolPayload(completeResult));
+    const imageUrl = completePayload.asset?.imageUrl ?? createPayload.assetUrl;
+    return {
+        path: filePath,
+        fileName,
+        mediaKind: "image",
+        objectKey: createPayload.objectKey,
+        assetUrl: createPayload.assetUrl,
+        url: imageUrl,
+        assetId: completePayload.asset?.id ?? null,
+        imageUrl,
+        contentType: metadata.contentType,
+        byteLength: fileStat.size,
+        alreadyCompleted: completePayload.alreadyCompleted ?? false,
+    };
+}
+async function uploadReferenceMediaFile(filePath, options) {
+    const fileStat = await stat(filePath);
+    if (!fileStat.isFile()) {
+        throw new Error(`${filePath} is not a file.`);
+    }
+    if (fileStat.size > MAX_REFERENCE_MEDIA_BYTES) {
+        throw new Error(`${filePath} is larger than 50 MB.`);
+    }
+    const fileName = path.basename(filePath);
+    const metadata = detectReferenceMedia(filePath);
+    const createResult = await executeRemoteCapability("create_reference_asset_upload", {
+        fileName,
+        contentType: metadata.contentType,
+        byteLength: fileStat.size,
+        fileExtension: metadata.fileExtension,
+        ...(options.projectId ? { projectId: options.projectId } : {}),
+    });
+    const createPayload = requireCreateUploadPayload(assertSuccessfulToolPayload(createResult));
+    const bytes = await readFile(filePath);
+    await uploadBytes({
+        uploadUrl: createPayload.uploadUrl,
+        method: createPayload.method ?? "PUT",
+        headers: createPayload.headers ?? { "Content-Type": metadata.contentType },
+        bytes,
+    });
+    return {
+        path: filePath,
+        fileName,
+        mediaKind: metadata.kind,
+        objectKey: createPayload.objectKey,
+        assetUrl: createPayload.assetUrl,
+        url: createPayload.assetUrl,
+        contentType: metadata.contentType,
+        byteLength: fileStat.size,
+    };
+}
+function buildUploadResult(uploads, nextSuggestedTool) {
     return {
         uploads,
         sourceAssetIds: uploads
             .map((upload) => upload.assetId)
             .filter((assetId) => Boolean(assetId)),
-        nextSuggestedTool: "create_product_reference_sheet",
+        referenceImageUrls: uploads
+            .filter((upload) => upload.mediaKind === "image")
+            .map((upload) => upload.url),
+        referenceVideoUrls: uploads
+            .filter((upload) => upload.mediaKind === "video")
+            .map((upload) => upload.url),
+        referenceAudioUrls: uploads
+            .filter((upload) => upload.mediaKind === "audio")
+            .map((upload) => upload.url),
+        nextSuggestedTool,
     };
 }
+export async function uploadProductReferenceImages(options) {
+    if (options.paths.length === 0) {
+        throw new Error("At least one image path is required.");
+    }
+    const imagePaths = await expandMediaInputPaths(options.paths, "image");
+    const uploads = [];
+    for (const filePath of imagePaths) {
+        uploads.push(await uploadProductReferenceImageFile(filePath, options));
+    }
+    return buildUploadResult(uploads, "create_product_reference_sheet");
+}
+export async function uploadReferenceMedia(options) {
+    if (options.paths.length === 0) {
+        throw new Error("At least one media path is required.");
+    }
+    const mode = options.mode ?? "media";
+    const mediaPaths = await expandMediaInputPaths(options.paths, mode);
+    const uploads = [];
+    for (const filePath of mediaPaths) {
+        uploads.push(await uploadReferenceMediaFile(filePath, options));
+    }
+    return buildUploadResult(uploads, "generate_video");
+}

package/dist/version.js

@@ -0,0 +1,32 @@
+export const CLI_PACKAGE_NAME = "@genrupt/cli";
+export const VERSION_CHECK_TIMEOUT_MS = 2_000;
+export function parseVersionParts(version) {
+    const [major = "0", minor = "0", patch = "0"] = version.split(/[.-]/, 3);
+    return [major, minor, patch].map((part) => Number.parseInt(part, 10) || 0);
+}
+export function compareVersions(left, right) {
+    const leftParts = parseVersionParts(left);
+    const rightParts = parseVersionParts(right);
+    for (let index = 0; index < leftParts.length; index += 1) {
+        if (leftParts[index] > rightParts[index])
+            return 1;
+        if (leftParts[index] < rightParts[index])
+            return -1;
+    }
+    return 0;
+}
+export function isVersionNewer(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}
+export function isVersionAtLeast(candidate, minimum) {
+    return compareVersions(candidate, minimum) >= 0;
+}
+export async function fetchLatestCliVersion() {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(CLI_PACKAGE_NAME)}/latest`, {
+        signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        return undefined;
+    const payload = (await response.json());
+    return typeof payload.version === "string" ? payload.version : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genrupt/cli",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Genrupt CLI for OAuth login, local file uploads, and local MCP bridge setup.",
   "license": "MIT",
   "repository": {