@enconvo/dxt 0.2.6

package/dist/schemas.js

@@ -0,0 +1,98 @@
+import * as z from "zod";
+export const McpServerConfigSchema = z.strictObject({
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+});
+export const DxtManifestAuthorSchema = z.strictObject({
+    name: z.string(),
+    email: z.string().email().optional(),
+    url: z.string().url().optional(),
+});
+export const DxtManifestRepositorySchema = z.strictObject({
+    type: z.string(),
+    url: z.string().url(),
+});
+export const DxtManifestPlatformOverrideSchema = McpServerConfigSchema.partial();
+export const DxtManifestMcpConfigSchema = McpServerConfigSchema.extend({
+    platform_overrides: z
+        .record(z.string(), DxtManifestPlatformOverrideSchema)
+        .optional(),
+});
+export const DxtManifestServerSchema = z.strictObject({
+    type: z.enum(["python", "node", "binary"]),
+    entry_point: z.string(),
+    mcp_config: DxtManifestMcpConfigSchema,
+});
+export const DxtManifestCompatibilitySchema = z
+    .strictObject({
+    claude_desktop: z.string().optional(),
+    platforms: z.array(z.enum(["darwin", "win32", "linux"])).optional(),
+    runtimes: z
+        .strictObject({
+        python: z.string().optional(),
+        node: z.string().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+export const DxtManifestToolSchema = z.strictObject({
+    name: z.string(),
+    description: z.string().optional(),
+});
+export const DxtManifestPromptSchema = z.strictObject({
+    name: z.string(),
+    description: z.string().optional(),
+    arguments: z.array(z.string()).optional(),
+    text: z.string(),
+});
+export const DxtUserConfigurationOptionSchema = z.strictObject({
+    type: z.enum(["string", "number", "boolean", "directory", "file"]),
+    title: z.string(),
+    description: z.string(),
+    required: z.boolean().optional(),
+    default: z
+        .union([z.string(), z.number(), z.boolean(), z.array(z.string())])
+        .optional(),
+    multiple: z.boolean().optional(),
+    sensitive: z.boolean().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    credentials: z.array(z.string()).optional(),
+});
+export const DxtUserConfigValuesSchema = z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]));
+export const DxtManifestSchema = z.strictObject({
+    $schema: z.string().optional(),
+    dxt_version: z.string(),
+    name: z.string(),
+    display_name: z.string().optional(),
+    version: z.string(),
+    description: z.string(),
+    long_description: z.string().optional(),
+    author: DxtManifestAuthorSchema,
+    repository: DxtManifestRepositorySchema.optional(),
+    homepage: z.string().url().optional(),
+    documentation: z.string().url().optional(),
+    support: z.string().url().optional(),
+    icon: z.string().optional(),
+    screenshots: z.array(z.string()).optional(),
+    server: DxtManifestServerSchema,
+    tools: z.array(DxtManifestToolSchema).optional(),
+    tools_generated: z.boolean().optional(),
+    prompts: z.array(DxtManifestPromptSchema).optional(),
+    prompts_generated: z.boolean().optional(),
+    keywords: z.array(z.string()).optional(),
+    license: z.string().optional(),
+    compatibility: DxtManifestCompatibilitySchema.optional(),
+    user_config: z
+        .record(z.string(), DxtUserConfigurationOptionSchema)
+        .optional(),
+});
+export const DxtSignatureInfoSchema = z.strictObject({
+    status: z.enum(["signed", "unsigned", "self-signed"]),
+    publisher: z.string().optional(),
+    issuer: z.string().optional(),
+    valid_from: z.string().optional(),
+    valid_to: z.string().optional(),
+    fingerprint: z.string().optional(),
+});

package/dist/shared/config.d.ts

@@ -0,0 +1,34 @@
+import type { DxtManifest, DxtUserConfigValues, Logger, McpServerConfig } from "../types.js";
+/**
+ * This file contains utility functions for handling DXT configuration,
+ * including variable replacement and MCP server configuration generation.
+ */
+/**
+ * Recursively replaces variables in any value. Handles strings, arrays, and objects.
+ *
+ * @param value The value to process
+ * @param variables Object containing variable replacements
+ * @returns The processed value with all variables replaced
+ */
+export declare function replaceVariables(value: unknown, variables: Record<string, string | string[]>): unknown;
+interface GetMcpConfigForManifestOptions {
+    manifest: DxtManifest;
+    extensionPath: string;
+    systemDirs: Record<string, string>;
+    userConfig: DxtUserConfigValues;
+    pathSeparator: string;
+    logger?: Logger;
+}
+export declare function getMcpConfigForManifest(options: GetMcpConfigForManifestOptions): Promise<McpServerConfig | undefined>;
+interface HasRequiredConfigMissingOptions {
+    manifest: DxtManifest;
+    userConfig?: DxtUserConfigValues;
+}
+/**
+ * Check if an extension has missing required configuration
+ * @param manifest The extension manifest
+ * @param userConfig The user configuration
+ * @returns true if required configuration is missing
+ */
+export declare function hasRequiredConfigMissing({ manifest, userConfig, }: HasRequiredConfigMissingOptions): boolean;
+export {};

package/dist/shared/config.js

@@ -0,0 +1,157 @@
+/**
+ * This file contains utility functions for handling DXT configuration,
+ * including variable replacement and MCP server configuration generation.
+ */
+/**
+ * Recursively replaces variables in any value. Handles strings, arrays, and objects.
+ *
+ * @param value The value to process
+ * @param variables Object containing variable replacements
+ * @returns The processed value with all variables replaced
+ */
+export function replaceVariables(value, variables) {
+    if (typeof value === "string") {
+        let result = value;
+        // Replace all variables in the string
+        for (const [key, replacement] of Object.entries(variables)) {
+            const pattern = new RegExp(`\\$\\{${key}\\}`, "g");
+            // Check if this pattern actually exists in the string
+            if (result.match(pattern)) {
+                if (Array.isArray(replacement)) {
+                    console.warn(`Cannot replace ${key} with array value in string context: "${value}"`, { key, replacement });
+                }
+                else {
+                    result = result.replace(pattern, replacement);
+                }
+            }
+        }
+        return result;
+    }
+    else if (Array.isArray(value)) {
+        // For arrays, we need to handle special case of array expansion
+        const result = [];
+        for (const item of value) {
+            if (typeof item === "string" &&
+                item.match(/^\$\{user_config\.[^}]+\}$/)) {
+                // This is a user config variable that might expand to multiple values
+                const varName = item.match(/^\$\{([^}]+)\}$/)?.[1];
+                if (varName && variables[varName]) {
+                    const replacement = variables[varName];
+                    if (Array.isArray(replacement)) {
+                        // Expand array inline
+                        result.push(...replacement);
+                    }
+                    else {
+                        result.push(replacement);
+                    }
+                }
+                else {
+                    // Variable not found, keep original
+                    result.push(item);
+                }
+            }
+            else {
+                // Recursively process non-variable items
+                result.push(replaceVariables(item, variables));
+            }
+        }
+        return result;
+    }
+    else if (value && typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = replaceVariables(val, variables);
+        }
+        return result;
+    }
+    return value;
+}
+export async function getMcpConfigForManifest(options) {
+    const { manifest, extensionPath, systemDirs, userConfig, pathSeparator, logger, } = options;
+    const baseConfig = manifest.server?.mcp_config;
+    if (!baseConfig) {
+        return undefined;
+    }
+    let result = {
+        ...baseConfig,
+    };
+    if (baseConfig.platform_overrides) {
+        if (process.platform in baseConfig.platform_overrides) {
+            const platformConfig = baseConfig.platform_overrides[process.platform];
+            result.command = platformConfig.command || result.command;
+            result.args = platformConfig.args || result.args;
+            result.env = platformConfig.env || result.env;
+        }
+    }
+    // Check if required configuration is missing
+    if (hasRequiredConfigMissing({ manifest, userConfig })) {
+        logger?.warn(`Extension ${manifest.name} has missing required configuration, skipping MCP config`);
+        return undefined;
+    }
+    const variables = {
+        __dirname: extensionPath,
+        pathSeparator,
+        "/": pathSeparator,
+        ...systemDirs,
+    };
+    // Build merged configuration from defaults and user settings
+    const mergedConfig = {};
+    // First, add defaults from manifest
+    if (manifest.user_config) {
+        for (const [key, configOption] of Object.entries(manifest.user_config)) {
+            if (configOption.default !== undefined) {
+                mergedConfig[key] = configOption.default;
+            }
+        }
+    }
+    // Then, override with user settings
+    if (userConfig) {
+        Object.assign(mergedConfig, userConfig);
+    }
+    // Add merged configuration variables for substitution
+    for (const [key, value] of Object.entries(mergedConfig)) {
+        // Convert user config to the format expected by variable substitution
+        const userConfigKey = `user_config.${key}`;
+        if (Array.isArray(value)) {
+            // Keep arrays as arrays for proper expansion
+            variables[userConfigKey] = value.map(String);
+        }
+        else if (typeof value === "boolean") {
+            // Convert booleans to "true"/"false" strings as per spec
+            variables[userConfigKey] = value ? "true" : "false";
+        }
+        else {
+            // Convert other types to strings
+            variables[userConfigKey] = String(value);
+        }
+    }
+    // Replace all variables in the config
+    result = replaceVariables(result, variables);
+    return result;
+}
+function isInvalidSingleValue(value) {
+    return value === undefined || value === null || value === "";
+}
+/**
+ * Check if an extension has missing required configuration
+ * @param manifest The extension manifest
+ * @param userConfig The user configuration
+ * @returns true if required configuration is missing
+ */
+export function hasRequiredConfigMissing({ manifest, userConfig, }) {
+    if (!manifest.user_config) {
+        return false;
+    }
+    const config = userConfig || {};
+    for (const [key, configOption] of Object.entries(manifest.user_config)) {
+        if (configOption.required) {
+            const value = config[key];
+            if (isInvalidSingleValue(value) ||
+                (Array.isArray(value) &&
+                    (value.length === 0 || value.some(isInvalidSingleValue)))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/shared/log.d.ts

@@ -0,0 +1,11 @@
+interface LoggerOptions {
+    silent?: boolean;
+}
+export declare function getLogger({ silent }?: LoggerOptions): {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+export {};

package/dist/shared/log.js

@@ -0,0 +1,29 @@
+export function getLogger({ silent = false } = {}) {
+    return {
+        log: (...args) => {
+            if (!silent) {
+                console.log(...args);
+            }
+        },
+        error: (...args) => {
+            if (!silent) {
+                console.error(...args);
+            }
+        },
+        warn: (...args) => {
+            if (!silent) {
+                console.warn(...args);
+            }
+        },
+        info: (...args) => {
+            if (!silent) {
+                console.info(...args);
+            }
+        },
+        debug: (...args) => {
+            if (!silent) {
+                console.debug(...args);
+            }
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type * as z from "zod";
+import type { DxtManifestAuthorSchema, DxtManifestCompatibilitySchema, DxtManifestMcpConfigSchema, DxtManifestPlatformOverrideSchema, DxtManifestPromptSchema, DxtManifestRepositorySchema, DxtManifestSchema, DxtManifestServerSchema, DxtManifestToolSchema, DxtSignatureInfoSchema, DxtUserConfigurationOptionSchema, DxtUserConfigValuesSchema, McpServerConfigSchema } from "./schemas.js";
+export type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
+export type DxtManifestAuthor = z.infer<typeof DxtManifestAuthorSchema>;
+export type DxtManifestRepository = z.infer<typeof DxtManifestRepositorySchema>;
+export type DxtManifestPlatformOverride = z.infer<typeof DxtManifestPlatformOverrideSchema>;
+export type DxtManifestMcpConfig = z.infer<typeof DxtManifestMcpConfigSchema>;
+export type DxtManifestServer = z.infer<typeof DxtManifestServerSchema>;
+export type DxtManifestCompatibility = z.infer<typeof DxtManifestCompatibilitySchema>;
+export type DxtManifestTool = z.infer<typeof DxtManifestToolSchema>;
+export type DxtManifestPrompt = z.infer<typeof DxtManifestPromptSchema>;
+export type DxtUserConfigurationOption = z.infer<typeof DxtUserConfigurationOptionSchema>;
+export type DxtUserConfigValues = z.infer<typeof DxtUserConfigValuesSchema>;
+export type DxtManifest = z.infer<typeof DxtManifestSchema>;
+/**
+ * Information about a DXT package signature
+ */
+export type DxtSignatureInfo = z.infer<typeof DxtSignatureInfoSchema>;
+export interface Logger {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@enconvo/dxt",
+  "description": "Tools for building Desktop Extensions",
+  "version": "0.2.6",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "require": "./dist/browser.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js",
+      "require": "./dist/node.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js",
+      "require": "./dist/cli.js"
+    }
+  },
+  "bin": {
+    "dxt": "dist/cli/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn run build:code",
+    "build:code": "tsc",
+    "build:schema": "node ./scripts/build-dxt-schema.js",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run build",
+    "fix": "eslint --ext .ts . --fix && prettier -w .",
+    "lint": "tsc -p ./tsconfig.json && eslint --ext .ts .",
+    "dev-version": "./scripts/create-dev-version.js"
+  },
+  "author": "Anthropic <support@anthropic.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.15.3",
+    "@types/node-forge": "1.3.11",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "eslint": "^8.43.0",
+    "eslint-config-prettier": "^8.10.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.3.2",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^6.0.1",
+    "commander": "^13.1.0",
+    "fflate": "^0.8.2",
+    "galactus": "^1.0.0",
+    "ignore": "^7.0.5",
+    "node-forge": "^1.3.1",
+    "pretty-bytes": "^5.6.0",
+    "zod": "^3.25.67"
+  },
+  "resolutions": {
+    "@babel/helpers": "7.27.1",
+    "@babel/parser": "7.27.3"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}