@kaitranntt/ccs 7.65.3 → 7.66.0-dev.1

package/dist/utils/hooks/index.js

@@ -7,9 +7,12 @@
  * @module utils/hooks
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureImageAnalyzerProfileHooks = exports.uninstallImageAnalyzerHook = exports.installImageAnalyzerHook = exports.hasImageAnalyzerHook = exports.getImageAnalyzerHookConfig = exports.getImageAnalyzerHookPath = exports.resolveImageAnalysisRuntimeStatus = exports.hydrateImageAnalysisRuntimeStatus = exports.normalizeImageAnalysisBackendId = exports.resolveImageAnalysisStatus = exports.canonicalizeImageAnalysisConfig = exports.getImageAnalysisHookEnv = void 0;
+exports.prepareImageAnalysisFallbackHook = exports.ensureImageAnalyzerProfileHooks = exports.uninstallImageAnalyzerHook = exports.installImageAnalyzerHook = exports.hasImageAnalyzerHook = exports.getImageAnalyzerHookConfig = exports.getImageAnalyzerHookPath = exports.resolveImageAnalysisRuntimeStatus = exports.hydrateImageAnalysisRuntimeStatus = exports.normalizeImageAnalysisBackendId = exports.resolveImageAnalysisStatus = exports.canonicalizeImageAnalysisConfig = exports.resolveImageAnalysisRuntimeConnection = exports.applyImageAnalysisRuntimeOverrides = exports.getImageAnalysisHookEnv = void 0;
+const image_analyzer_hook_installer_1 = require("./image-analyzer-hook-installer");
 var get_image_analysis_hook_env_1 = require("./get-image-analysis-hook-env");
 Object.defineProperty(exports, "getImageAnalysisHookEnv", { enumerable: true, get: function () { return get_image_analysis_hook_env_1.getImageAnalysisHookEnv; } });
+Object.defineProperty(exports, "applyImageAnalysisRuntimeOverrides", { enumerable: true, get: function () { return get_image_analysis_hook_env_1.applyImageAnalysisRuntimeOverrides; } });
+Object.defineProperty(exports, "resolveImageAnalysisRuntimeConnection", { enumerable: true, get: function () { return get_image_analysis_hook_env_1.resolveImageAnalysisRuntimeConnection; } });
 var image_analysis_backend_resolver_1 = require("./image-analysis-backend-resolver");
 Object.defineProperty(exports, "canonicalizeImageAnalysisConfig", { enumerable: true, get: function () { return image_analysis_backend_resolver_1.canonicalizeImageAnalysisConfig; } });
 Object.defineProperty(exports, "resolveImageAnalysisStatus", { enumerable: true, get: function () { return image_analysis_backend_resolver_1.resolveImageAnalysisStatus; } });
@@ -17,12 +20,16 @@ Object.defineProperty(exports, "normalizeImageAnalysisBackendId", { enumerable:
 var image_analysis_runtime_status_1 = require("./image-analysis-runtime-status");
 Object.defineProperty(exports, "hydrateImageAnalysisRuntimeStatus", { enumerable: true, get: function () { return image_analysis_runtime_status_1.hydrateImageAnalysisRuntimeStatus; } });
 Object.defineProperty(exports, "resolveImageAnalysisRuntimeStatus", { enumerable: true, get: function () { return image_analysis_runtime_status_1.resolveImageAnalysisRuntimeStatus; } });
-var image_analyzer_hook_installer_1 = require("./image-analyzer-hook-installer");
-Object.defineProperty(exports, "getImageAnalyzerHookPath", { enumerable: true, get: function () { return image_analyzer_hook_installer_1.getImageAnalyzerHookPath; } });
-Object.defineProperty(exports, "getImageAnalyzerHookConfig", { enumerable: true, get: function () { return image_analyzer_hook_installer_1.getImageAnalyzerHookConfig; } });
-Object.defineProperty(exports, "hasImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_1.hasImageAnalyzerHook; } });
-Object.defineProperty(exports, "installImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_1.installImageAnalyzerHook; } });
-Object.defineProperty(exports, "uninstallImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_1.uninstallImageAnalyzerHook; } });
+var image_analyzer_hook_installer_2 = require("./image-analyzer-hook-installer");
+Object.defineProperty(exports, "getImageAnalyzerHookPath", { enumerable: true, get: function () { return image_analyzer_hook_installer_2.getImageAnalyzerHookPath; } });
+Object.defineProperty(exports, "getImageAnalyzerHookConfig", { enumerable: true, get: function () { return image_analyzer_hook_installer_2.getImageAnalyzerHookConfig; } });
+Object.defineProperty(exports, "hasImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_2.hasImageAnalyzerHook; } });
+Object.defineProperty(exports, "installImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_2.installImageAnalyzerHook; } });
+Object.defineProperty(exports, "uninstallImageAnalyzerHook", { enumerable: true, get: function () { return image_analyzer_hook_installer_2.uninstallImageAnalyzerHook; } });
 var image_analyzer_profile_hook_injector_1 = require("./image-analyzer-profile-hook-injector");
 Object.defineProperty(exports, "ensureImageAnalyzerProfileHooks", { enumerable: true, get: function () { return image_analyzer_profile_hook_injector_1.ensureProfileHooks; } });
+function prepareImageAnalysisFallbackHook() {
+    return (0, image_analyzer_hook_installer_1.hasImageAnalyzerHook)() || (0, image_analyzer_hook_installer_1.installImageAnalyzerHook)();
+}
+exports.prepareImageAnalysisFallbackHook = prepareImageAnalysisFallbackHook;
 //# sourceMappingURL=index.js.map

package/dist/utils/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/hooks/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,6EAAwE;AAA/D,sIAAA,uBAAuB,OAAA;AAChC,qFAM2C;AALzC,kJAAA,+BAA+B,OAAA;AAC/B,6IAAA,0BAA0B,OAAA;AAC1B,kJAAA,+BAA+B,OAAA;AAIjC,iFAGyC;AAFvC,kJAAA,iCAAiC,OAAA;AACjC,kJAAA,iCAAiC,OAAA;AAEnC,iFAMyC;AALvC,yIAAA,wBAAwB,OAAA;AACxB,2IAAA,0BAA0B,OAAA;AAC1B,qIAAA,oBAAoB,OAAA;AACpB,yIAAA,wBAAwB,OAAA;AACxB,2IAAA,0BAA0B,OAAA;AAE5B,+FAA+G;AAAtG,uJAAA,kBAAkB,OAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/hooks/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,mFAGyC;AAEzC,6EAOuC;AANrC,sIAAA,uBAAuB,OAAA;AACvB,iJAAA,kCAAkC,OAAA;AAClC,oJAAA,qCAAqC,OAAA;AAKvC,qFAM2C;AALzC,kJAAA,+BAA+B,OAAA;AAC/B,6IAAA,0BAA0B,OAAA;AAC1B,kJAAA,+BAA+B,OAAA;AAIjC,iFAGyC;AAFvC,kJAAA,iCAAiC,OAAA;AACjC,kJAAA,iCAAiC,OAAA;AAEnC,iFAMyC;AALvC,yIAAA,wBAAwB,OAAA;AACxB,2IAAA,0BAA0B,OAAA;AAC1B,qIAAA,oBAAoB,OAAA;AACpB,yIAAA,wBAAwB,OAAA;AACxB,2IAAA,0BAA0B,OAAA;AAE5B,+FAA+G;AAAtG,uJAAA,kBAAkB,OAAmC;AAE9D,SAAgB,gCAAgC;IAC9C,OAAO,IAAA,oDAA6B,GAAE,IAAI,IAAA,wDAA8B,GAAE,CAAC;AAC7E,CAAC;AAFD,4EAEC"}

package/dist/utils/image-analysis/claude-tool-args.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Claude launch argument helpers for first-class Image Analysis.
+ */
+export declare function appendThirdPartyImageAnalysisToolArgs(args: string[]): string[];
+export declare function getImageAnalysisSteeringPrompt(): string;
+//# sourceMappingURL=claude-tool-args.d.ts.map

package/dist/utils/image-analysis/claude-tool-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-tool-args.d.ts","sourceRoot":"","sources":["../../../src/utils/image-analysis/claude-tool-args.ts"],"names":[],"mappings":"AAAA;;GAEG;AAiEH,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAE9E;AAED,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/utils/image-analysis/claude-tool-args.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Claude launch argument helpers for first-class Image Analysis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImageAnalysisSteeringPrompt = exports.appendThirdPartyImageAnalysisToolArgs = void 0;
+const APPEND_SYSTEM_PROMPT_FLAG = '--append-system-prompt';
+const IMAGE_ANALYSIS_STEERING_PROMPT = 'For local image or PDF files, prefer the CCS MCP tool ImageAnalysis instead of Read. Use Read for text, code, and other plain files. If the user asks a specific question about the visual, pass that question as the focus field when useful. If ImageAnalysis is unavailable or fails, you may fall back to Read.';
+function splitArgsAtTerminator(args) {
+    const terminatorIndex = args.indexOf('--');
+    if (terminatorIndex === -1) {
+        return { optionArgs: args, trailingArgs: [] };
+    }
+    return {
+        optionArgs: args.slice(0, terminatorIndex),
+        trailingArgs: args.slice(terminatorIndex),
+    };
+}
+function getImmediateFlagValue(args, index) {
+    const value = args[index + 1];
+    if (value === undefined || value === '--' || value.startsWith('--')) {
+        return null;
+    }
+    return value;
+}
+function hasExactFlagValue(args, flag, expectedValue) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === flag) {
+            const value = getImmediateFlagValue(args, index);
+            if (value === expectedValue) {
+                return true;
+            }
+            continue;
+        }
+        if (arg === `${flag}=${expectedValue}`) {
+            return true;
+        }
+        if (arg.startsWith(`${flag}=`) && arg.slice(flag.length + 1) === expectedValue) {
+            return true;
+        }
+    }
+    return false;
+}
+function ensureImageAnalysisSteeringPrompt(args) {
+    const { optionArgs, trailingArgs } = splitArgsAtTerminator(args);
+    if (hasExactFlagValue(optionArgs, APPEND_SYSTEM_PROMPT_FLAG, IMAGE_ANALYSIS_STEERING_PROMPT)) {
+        return args;
+    }
+    return [
+        ...optionArgs,
+        APPEND_SYSTEM_PROMPT_FLAG,
+        IMAGE_ANALYSIS_STEERING_PROMPT,
+        ...trailingArgs,
+    ];
+}
+function appendThirdPartyImageAnalysisToolArgs(args) {
+    return ensureImageAnalysisSteeringPrompt(args);
+}
+exports.appendThirdPartyImageAnalysisToolArgs = appendThirdPartyImageAnalysisToolArgs;
+function getImageAnalysisSteeringPrompt() {
+    return IMAGE_ANALYSIS_STEERING_PROMPT;
+}
+exports.getImageAnalysisSteeringPrompt = getImageAnalysisSteeringPrompt;
+//# sourceMappingURL=claude-tool-args.js.map

package/dist/utils/image-analysis/claude-tool-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-tool-args.js","sourceRoot":"","sources":["../../../src/utils/image-analysis/claude-tool-args.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,MAAM,yBAAyB,GAAG,wBAAwB,CAAC;AAC3D,MAAM,8BAA8B,GAClC,qTAAqT,CAAC;AAExT,SAAS,qBAAqB,CAAC,IAAc;IAC3C,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,eAAe,KAAK,CAAC,CAAC,EAAE,CAAC;QAC3B,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC;IAChD,CAAC;IAED,OAAO;QACL,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,eAAe,CAAC;QAC1C,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;KAC1C,CAAC;AACJ,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAc,EAAE,KAAa;IAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC9B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACpE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAc,EAAE,IAAY,EAAE,aAAqB;IAC5E,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAExB,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YACjB,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACjD,IAAI,KAAK,KAAK,aAAa,EAAE,CAAC;gBAC5B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,SAAS;QACX,CAAC;QAED,IAAI,GAAG,KAAK,GAAG,IAAI,IAAI,aAAa,EAAE,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,aAAa,EAAE,CAAC;YAC/E,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,iCAAiC,CAAC,IAAc;IACvD,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAEjE,IAAI,iBAAiB,CAAC,UAAU,EAAE,yBAAyB,EAAE,8BAA8B,CAAC,EAAE,CAAC;QAC7F,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,GAAG,UAAU;QACb,yBAAyB;QACzB,8BAA8B;QAC9B,GAAG,YAAY;KAChB,CAAC;AACJ,CAAC;AAED,SAAgB,qCAAqC,CAAC,IAAc;IAClE,OAAO,iCAAiC,CAAC,IAAI,CAAC,CAAC;AACjD,CAAC;AAFD,sFAEC;AAED,SAAgB,8BAA8B;IAC5C,OAAO,8BAA8B,CAAC;AACxC,CAAC;AAFD,wEAEC"}

package/dist/utils/image-analysis/index.d.ts

@@ -4,4 +4,8 @@
  * Exports hook installer functions for prompt management
  */
 export { getPromptsDir, installImageAnalysisPrompts } from './hook-installer';
+export { getImageAnalysisMcpServerName, getImageAnalysisMcpServerPath, getImageAnalysisMcpRuntimePath, hasImageAnalysisMcpServerInstalled, hasImageAnalysisMcpConfig, hasImageAnalysisMcpReady, installImageAnalysisMcpServer, ensureImageAnalysisMcpConfig, ensureImageAnalysisMcp, uninstallImageAnalysisMcpServer, removeImageAnalysisMcpConfig, uninstallImageAnalysisMcp, syncImageAnalysisMcpToConfigDir, ensureImageAnalysisMcpOrThrow, } from './mcp-installer';
+export { appendThirdPartyImageAnalysisToolArgs, getImageAnalysisSteeringPrompt, } from './claude-tool-args';
+export declare const IMAGE_ANALYSIS_PROMPT_TEMPLATES: readonly ["default", "screenshot", "document"];
+export type ImageAnalysisPromptTemplate = (typeof IMAGE_ANALYSIS_PROMPT_TEMPLATES)[number];
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/image-analysis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/image-analysis/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/image-analysis/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,8BAA8B,EAC9B,kCAAkC,EAClC,yBAAyB,EACzB,wBAAwB,EACxB,6BAA6B,EAC7B,4BAA4B,EAC5B,sBAAsB,EACtB,+BAA+B,EAC/B,4BAA4B,EAC5B,yBAAyB,EACzB,+BAA+B,EAC/B,6BAA6B,GAC9B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,qCAAqC,EACrC,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,+BAA+B,gDAAiD,CAAC;AAC9F,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,+BAA+B,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/utils/image-analysis/index.js

@@ -5,8 +5,27 @@
  * Exports hook installer functions for prompt management
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installImageAnalysisPrompts = exports.getPromptsDir = void 0;
+exports.IMAGE_ANALYSIS_PROMPT_TEMPLATES = exports.getImageAnalysisSteeringPrompt = exports.appendThirdPartyImageAnalysisToolArgs = exports.ensureImageAnalysisMcpOrThrow = exports.syncImageAnalysisMcpToConfigDir = exports.uninstallImageAnalysisMcp = exports.removeImageAnalysisMcpConfig = exports.uninstallImageAnalysisMcpServer = exports.ensureImageAnalysisMcp = exports.ensureImageAnalysisMcpConfig = exports.installImageAnalysisMcpServer = exports.hasImageAnalysisMcpReady = exports.hasImageAnalysisMcpConfig = exports.hasImageAnalysisMcpServerInstalled = exports.getImageAnalysisMcpRuntimePath = exports.getImageAnalysisMcpServerPath = exports.getImageAnalysisMcpServerName = exports.installImageAnalysisPrompts = exports.getPromptsDir = void 0;
 var hook_installer_1 = require("./hook-installer");
 Object.defineProperty(exports, "getPromptsDir", { enumerable: true, get: function () { return hook_installer_1.getPromptsDir; } });
 Object.defineProperty(exports, "installImageAnalysisPrompts", { enumerable: true, get: function () { return hook_installer_1.installImageAnalysisPrompts; } });
+var mcp_installer_1 = require("./mcp-installer");
+Object.defineProperty(exports, "getImageAnalysisMcpServerName", { enumerable: true, get: function () { return mcp_installer_1.getImageAnalysisMcpServerName; } });
+Object.defineProperty(exports, "getImageAnalysisMcpServerPath", { enumerable: true, get: function () { return mcp_installer_1.getImageAnalysisMcpServerPath; } });
+Object.defineProperty(exports, "getImageAnalysisMcpRuntimePath", { enumerable: true, get: function () { return mcp_installer_1.getImageAnalysisMcpRuntimePath; } });
+Object.defineProperty(exports, "hasImageAnalysisMcpServerInstalled", { enumerable: true, get: function () { return mcp_installer_1.hasImageAnalysisMcpServerInstalled; } });
+Object.defineProperty(exports, "hasImageAnalysisMcpConfig", { enumerable: true, get: function () { return mcp_installer_1.hasImageAnalysisMcpConfig; } });
+Object.defineProperty(exports, "hasImageAnalysisMcpReady", { enumerable: true, get: function () { return mcp_installer_1.hasImageAnalysisMcpReady; } });
+Object.defineProperty(exports, "installImageAnalysisMcpServer", { enumerable: true, get: function () { return mcp_installer_1.installImageAnalysisMcpServer; } });
+Object.defineProperty(exports, "ensureImageAnalysisMcpConfig", { enumerable: true, get: function () { return mcp_installer_1.ensureImageAnalysisMcpConfig; } });
+Object.defineProperty(exports, "ensureImageAnalysisMcp", { enumerable: true, get: function () { return mcp_installer_1.ensureImageAnalysisMcp; } });
+Object.defineProperty(exports, "uninstallImageAnalysisMcpServer", { enumerable: true, get: function () { return mcp_installer_1.uninstallImageAnalysisMcpServer; } });
+Object.defineProperty(exports, "removeImageAnalysisMcpConfig", { enumerable: true, get: function () { return mcp_installer_1.removeImageAnalysisMcpConfig; } });
+Object.defineProperty(exports, "uninstallImageAnalysisMcp", { enumerable: true, get: function () { return mcp_installer_1.uninstallImageAnalysisMcp; } });
+Object.defineProperty(exports, "syncImageAnalysisMcpToConfigDir", { enumerable: true, get: function () { return mcp_installer_1.syncImageAnalysisMcpToConfigDir; } });
+Object.defineProperty(exports, "ensureImageAnalysisMcpOrThrow", { enumerable: true, get: function () { return mcp_installer_1.ensureImageAnalysisMcpOrThrow; } });
+var claude_tool_args_1 = require("./claude-tool-args");
+Object.defineProperty(exports, "appendThirdPartyImageAnalysisToolArgs", { enumerable: true, get: function () { return claude_tool_args_1.appendThirdPartyImageAnalysisToolArgs; } });
+Object.defineProperty(exports, "getImageAnalysisSteeringPrompt", { enumerable: true, get: function () { return claude_tool_args_1.getImageAnalysisSteeringPrompt; } });
+exports.IMAGE_ANALYSIS_PROMPT_TEMPLATES = ['default', 'screenshot', 'document'];
 //# sourceMappingURL=index.js.map

package/dist/utils/image-analysis/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/image-analysis/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,mDAA8E;AAArE,+GAAA,aAAa,OAAA;AAAE,6HAAA,2BAA2B,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/image-analysis/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,mDAA8E;AAArE,+GAAA,aAAa,OAAA;AAAE,6HAAA,2BAA2B,OAAA;AACnD,iDAeyB;AAdvB,8HAAA,6BAA6B,OAAA;AAC7B,8HAAA,6BAA6B,OAAA;AAC7B,+HAAA,8BAA8B,OAAA;AAC9B,mIAAA,kCAAkC,OAAA;AAClC,0HAAA,yBAAyB,OAAA;AACzB,yHAAA,wBAAwB,OAAA;AACxB,8HAAA,6BAA6B,OAAA;AAC7B,6HAAA,4BAA4B,OAAA;AAC5B,uHAAA,sBAAsB,OAAA;AACtB,gIAAA,+BAA+B,OAAA;AAC/B,6HAAA,4BAA4B,OAAA;AAC5B,0HAAA,yBAAyB,OAAA;AACzB,gIAAA,+BAA+B,OAAA;AAC/B,8HAAA,6BAA6B,OAAA;AAE/B,uDAG4B;AAF1B,yIAAA,qCAAqC,OAAA;AACrC,kIAAA,8BAA8B,OAAA;AAGnB,QAAA,+BAA+B,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,UAAU,CAAU,CAAC"}

package/dist/utils/image-analysis/mcp-installer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Image Analysis MCP installer and ~/.claude.json provisioning.
+ */
+export declare function getImageAnalysisMcpServerName(): string;
+export declare function getImageAnalysisMcpServerPath(): string;
+export declare function getImageAnalysisMcpRuntimePath(): string;
+export declare function hasImageAnalysisMcpServerInstalled(): boolean;
+export declare function hasImageAnalysisMcpConfig(configPath?: string): boolean;
+export declare function hasImageAnalysisMcpReady(configPath?: string): boolean;
+export declare function installImageAnalysisMcpServer(): boolean;
+export declare function ensureImageAnalysisMcpConfig(): boolean;
+export declare function ensureImageAnalysisMcp(): boolean;
+export declare function syncImageAnalysisMcpToConfigDir(claudeConfigDir: string | undefined): boolean;
+export declare function uninstallImageAnalysisMcpServer(): boolean;
+export declare function removeImageAnalysisMcpConfig(): boolean;
+export declare function uninstallImageAnalysisMcp(): boolean;
+export declare function ensureImageAnalysisMcpOrThrow(): boolean;
+//# sourceMappingURL=mcp-installer.d.ts.map

package/dist/utils/image-analysis/mcp-installer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-installer.d.ts","sourceRoot":"","sources":["../../../src/utils/image-analysis/mcp-installer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgCH,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD;AAED,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD;AA8GD,wBAAgB,kCAAkC,IAAI,OAAO,CAK5D;AAED,wBAAgB,yBAAyB,CAAC,UAAU,SAA4B,GAAG,OAAO,CAuBzF;AAED,wBAAgB,wBAAwB,CAAC,UAAU,SAA4B,GAAG,OAAO,CAExF;AAqED,wBAAgB,6BAA6B,IAAI,OAAO,CAgFvD;AAED,wBAAgB,4BAA4B,IAAI,OAAO,CA8EtD;AAED,wBAAgB,sBAAsB,IAAI,OAAO,CAShD;AAED,wBAAgB,+BAA+B,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAM5F;AAED,wBAAgB,+BAA+B,IAAI,OAAO,CAwBzD;AAED,wBAAgB,4BAA4B,IAAI,OAAO,CAWtD;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAInD;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAgBvD"}

package/dist/utils/image-analysis/mcp-installer.js

@@ -0,0 +1,447 @@
+"use strict";
+/**
+ * Image Analysis MCP installer and ~/.claude.json provisioning.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureImageAnalysisMcpOrThrow = exports.uninstallImageAnalysisMcp = exports.removeImageAnalysisMcpConfig = exports.uninstallImageAnalysisMcpServer = exports.syncImageAnalysisMcpToConfigDir = exports.ensureImageAnalysisMcp = exports.ensureImageAnalysisMcpConfig = exports.installImageAnalysisMcpServer = exports.hasImageAnalysisMcpReady = exports.hasImageAnalysisMcpConfig = exports.hasImageAnalysisMcpServerInstalled = exports.getImageAnalysisMcpRuntimePath = exports.getImageAnalysisMcpServerPath = exports.getImageAnalysisMcpServerName = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const lockfile = __importStar(require("proper-lockfile"));
+const unified_config_loader_1 = require("../../config/unified-config-loader");
+const config_manager_1 = require("../config-manager");
+const claude_config_path_1 = require("../claude-config-path");
+const ui_1 = require("../ui");
+const instance_manager_1 = require("../../management/instance-manager");
+const hook_installer_1 = require("./hook-installer");
+const IMAGE_ANALYSIS_MCP_SERVER = 'ccs-image-analysis-server.cjs';
+const IMAGE_ANALYSIS_MCP_RUNTIME = 'image-analysis-runtime.cjs';
+const IMAGE_ANALYSIS_MCP_SERVER_NAME = 'ccs-image-analysis';
+function getCcsMcpDir() {
+    return path.join((0, config_manager_1.getCcsDir)(), 'mcp');
+}
+function getImageAnalysisMcpServerName() {
+    return IMAGE_ANALYSIS_MCP_SERVER_NAME;
+}
+exports.getImageAnalysisMcpServerName = getImageAnalysisMcpServerName;
+function getImageAnalysisMcpServerPath() {
+    return path.join(getCcsMcpDir(), IMAGE_ANALYSIS_MCP_SERVER);
+}
+exports.getImageAnalysisMcpServerPath = getImageAnalysisMcpServerPath;
+function getImageAnalysisMcpRuntimePath() {
+    return path.join(getCcsMcpDir(), IMAGE_ANALYSIS_MCP_RUNTIME);
+}
+exports.getImageAnalysisMcpRuntimePath = getImageAnalysisMcpRuntimePath;
+function hasMatchingContents(sourcePath, destinationPath) {
+    if (!fs.existsSync(destinationPath)) {
+        return false;
+    }
+    const source = fs.readFileSync(sourcePath);
+    try {
+        const destination = fs.readFileSync(destinationPath);
+        return source.equals(destination);
+    }
+    catch (error) {
+        if (process.env.CCS_DEBUG) {
+            console.error((0, ui_1.warn)(`Existing Image Analysis MCP server is unreadable: ${error.message}`));
+        }
+        return false;
+    }
+}
+function getTempPath(targetPath) {
+    const suffix = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    return `${targetPath}.${suffix}.tmp`;
+}
+function resolveBundledArtifactSourcePath(fileName) {
+    const possiblePaths = [
+        path.join(__dirname, '..', '..', '..', 'lib', 'mcp', fileName),
+        path.join(__dirname, '..', '..', 'lib', 'mcp', fileName),
+        path.join(__dirname, '..', 'lib', 'mcp', fileName),
+        path.join(__dirname, '..', '..', '..', 'lib', 'hooks', fileName),
+        path.join(__dirname, '..', '..', 'lib', 'hooks', fileName),
+        path.join(__dirname, '..', 'lib', 'hooks', fileName),
+    ];
+    for (const candidate of possiblePaths) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function readClaudeUserConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writeClaudeUserConfig(configPath, config) {
+    const tempPath = getTempPath(configPath);
+    const fileMode = fs.existsSync(configPath) ? fs.statSync(configPath).mode & 0o777 : 0o600;
+    try {
+        fs.writeFileSync(tempPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        fs.chmodSync(tempPath, fileMode);
+        fs.renameSync(tempPath, configPath);
+        return true;
+    }
+    finally {
+        if (fs.existsSync(tempPath)) {
+            fs.unlinkSync(tempPath);
+        }
+    }
+}
+function withClaudeUserConfigLock(configPath, callback) {
+    const configDir = path.dirname(configPath);
+    const lockTarget = path.join(configDir, `${path.basename(configPath)}.ccs-lock`);
+    let release;
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+    }
+    if (!fs.existsSync(lockTarget)) {
+        fs.writeFileSync(lockTarget, '', { encoding: 'utf8', mode: 0o600 });
+    }
+    try {
+        release = lockfile.lockSync(lockTarget, { stale: 10000 });
+        return callback();
+    }
+    finally {
+        if (release) {
+            try {
+                release();
+            }
+            catch {
+                // Best-effort release.
+            }
+        }
+    }
+}
+function isLockUnavailableError(error) {
+    const code = error?.code;
+    return code === 'ELOCKED' || code === 'ENOTACQUIRED';
+}
+function hasImageAnalysisMcpServerInstalled() {
+    return (fs.existsSync(getImageAnalysisMcpServerPath()) &&
+        fs.existsSync(getImageAnalysisMcpRuntimePath()));
+}
+exports.hasImageAnalysisMcpServerInstalled = hasImageAnalysisMcpServerInstalled;
+function hasImageAnalysisMcpConfig(configPath = (0, claude_config_path_1.getClaudeUserConfigPath)()) {
+    const config = readClaudeUserConfig(configPath);
+    if (config === null) {
+        return false;
+    }
+    const existingServers = config.mcpServers && typeof config.mcpServers === 'object' && !Array.isArray(config.mcpServers)
+        ? config.mcpServers
+        : {};
+    const currentConfig = existingServers[IMAGE_ANALYSIS_MCP_SERVER_NAME];
+    return (typeof currentConfig === 'object' &&
+        currentConfig !== null &&
+        JSON.stringify(currentConfig) ===
+            JSON.stringify({
+                type: 'stdio',
+                command: 'node',
+                args: [getImageAnalysisMcpServerPath()],
+                env: {},
+            }));
+}
+exports.hasImageAnalysisMcpConfig = hasImageAnalysisMcpConfig;
+function hasImageAnalysisMcpReady(configPath = (0, claude_config_path_1.getClaudeUserConfigPath)()) {
+    return hasImageAnalysisMcpServerInstalled() && hasImageAnalysisMcpConfig(configPath);
+}
+exports.hasImageAnalysisMcpReady = hasImageAnalysisMcpReady;
+function removeManagedServerConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return false;
+    }
+    try {
+        return withClaudeUserConfigLock(configPath, () => {
+            const config = readClaudeUserConfig(configPath);
+            if (config === null) {
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.warn)(`Malformed Claude config prevents MCP cleanup: ${configPath}`));
+                }
+                return false;
+            }
+            const existingServers = config.mcpServers &&
+                typeof config.mcpServers === 'object' &&
+                !Array.isArray(config.mcpServers)
+                ? { ...config.mcpServers }
+                : {};
+            if (!(IMAGE_ANALYSIS_MCP_SERVER_NAME in existingServers)) {
+                return false;
+            }
+            delete existingServers[IMAGE_ANALYSIS_MCP_SERVER_NAME];
+            const nextConfig = { ...config };
+            if (Object.keys(existingServers).length === 0) {
+                delete nextConfig.mcpServers;
+            }
+            else {
+                nextConfig.mcpServers = existingServers;
+            }
+            try {
+                writeClaudeUserConfig(configPath, nextConfig);
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.info)(`Removed Image Analysis MCP config from ${configPath}`));
+                }
+                return true;
+            }
+            catch (error) {
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.warn)(`Failed to remove Image Analysis MCP config from ${configPath}: ${error.message}`));
+                }
+                return false;
+            }
+        });
+    }
+    catch (error) {
+        if (isLockUnavailableError(error)) {
+            if (process.env.CCS_DEBUG) {
+                console.error((0, ui_1.warn)(`Image Analysis MCP cleanup skipped because ${configPath} is locked by another process`));
+            }
+            return false;
+        }
+        throw error;
+    }
+}
+function installImageAnalysisMcpServer() {
+    const config = (0, unified_config_loader_1.getImageAnalysisConfig)();
+    if (!config.enabled) {
+        return false;
+    }
+    const artifacts = [
+        {
+            fileName: IMAGE_ANALYSIS_MCP_SERVER,
+            sourcePath: resolveBundledArtifactSourcePath(IMAGE_ANALYSIS_MCP_SERVER),
+            destinationPath: getImageAnalysisMcpServerPath(),
+        },
+        {
+            fileName: IMAGE_ANALYSIS_MCP_RUNTIME,
+            sourcePath: resolveBundledArtifactSourcePath(IMAGE_ANALYSIS_MCP_RUNTIME),
+            destinationPath: getImageAnalysisMcpRuntimePath(),
+        },
+    ];
+    const missingArtifact = artifacts.find((artifact) => !artifact.sourcePath);
+    if (missingArtifact) {
+        if (process.env.CCS_DEBUG) {
+            console.error((0, ui_1.warn)(`Image Analysis MCP runtime source not found: ${missingArtifact.fileName}`));
+        }
+        return false;
+    }
+    const mcpDir = getCcsMcpDir();
+    if (!fs.existsSync(mcpDir)) {
+        fs.mkdirSync(mcpDir, { recursive: true, mode: 0o700 });
+    }
+    try {
+        for (const artifact of artifacts) {
+            const sourcePath = artifact.sourcePath;
+            if (!sourcePath) {
+                continue;
+            }
+            if (hasMatchingContents(sourcePath, artifact.destinationPath)) {
+                continue;
+            }
+            const tempPath = getTempPath(artifact.destinationPath);
+            try {
+                fs.copyFileSync(sourcePath, tempPath);
+                fs.chmodSync(tempPath, 0o755);
+                try {
+                    fs.renameSync(tempPath, artifact.destinationPath);
+                }
+                catch (renameError) {
+                    const errorCode = renameError.code;
+                    if (errorCode !== 'EEXIST' && errorCode !== 'EPERM') {
+                        throw renameError;
+                    }
+                    if (!hasMatchingContents(sourcePath, artifact.destinationPath)) {
+                        fs.copyFileSync(tempPath, artifact.destinationPath);
+                        fs.chmodSync(artifact.destinationPath, 0o755);
+                    }
+                }
+            }
+            finally {
+                if (fs.existsSync(tempPath)) {
+                    fs.unlinkSync(tempPath);
+                }
+            }
+        }
+        (0, hook_installer_1.installImageAnalysisPrompts)();
+        return true;
+    }
+    catch (error) {
+        if (process.env.CCS_DEBUG) {
+            console.error((0, ui_1.warn)(`Failed to install Image Analysis MCP server: ${error.message}`));
+        }
+        return false;
+    }
+}
+exports.installImageAnalysisMcpServer = installImageAnalysisMcpServer;
+function ensureImageAnalysisMcpConfig() {
+    const imageConfig = (0, unified_config_loader_1.getImageAnalysisConfig)();
+    if (!imageConfig.enabled) {
+        return false;
+    }
+    const claudeUserConfigPath = (0, claude_config_path_1.getClaudeUserConfigPath)();
+    const claudeUserConfigDir = path.dirname(claudeUserConfigPath);
+    if (!fs.existsSync(claudeUserConfigDir)) {
+        fs.mkdirSync(claudeUserConfigDir, { recursive: true, mode: 0o700 });
+    }
+    const desiredServerConfig = {
+        type: 'stdio',
+        command: 'node',
+        args: [getImageAnalysisMcpServerPath()],
+        env: {},
+    };
+    try {
+        return withClaudeUserConfigLock(claudeUserConfigPath, () => {
+            const config = readClaudeUserConfig(claudeUserConfigPath);
+            if (config === null) {
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.warn)('Malformed ~/.claude.json prevents Image Analysis MCP provisioning'));
+                }
+                return false;
+            }
+            const existingServers = config.mcpServers &&
+                typeof config.mcpServers === 'object' &&
+                !Array.isArray(config.mcpServers)
+                ? config.mcpServers
+                : {};
+            const currentConfig = existingServers[IMAGE_ANALYSIS_MCP_SERVER_NAME];
+            if (typeof currentConfig === 'object' &&
+                currentConfig !== null &&
+                JSON.stringify(currentConfig) === JSON.stringify(desiredServerConfig)) {
+                return true;
+            }
+            const nextConfig = {
+                ...config,
+                mcpServers: {
+                    ...existingServers,
+                    [IMAGE_ANALYSIS_MCP_SERVER_NAME]: desiredServerConfig,
+                },
+            };
+            try {
+                writeClaudeUserConfig(claudeUserConfigPath, nextConfig);
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.info)(`Ensured Image Analysis MCP config in ${claudeUserConfigPath}`));
+                }
+                return true;
+            }
+            catch (error) {
+                if (process.env.CCS_DEBUG) {
+                    console.error((0, ui_1.warn)(`Failed to update ~/.claude.json: ${error.message}`));
+                }
+                return false;
+            }
+        });
+    }
+    catch (error) {
+        if (isLockUnavailableError(error)) {
+            if (process.env.CCS_DEBUG) {
+                console.error((0, ui_1.warn)(`Image Analysis MCP provisioning skipped because ${claudeUserConfigPath} is locked by another process`));
+            }
+            return false;
+        }
+        throw error;
+    }
+}
+exports.ensureImageAnalysisMcpConfig = ensureImageAnalysisMcpConfig;
+function ensureImageAnalysisMcp() {
+    const imageConfig = (0, unified_config_loader_1.getImageAnalysisConfig)();
+    if (!imageConfig.enabled) {
+        return false;
+    }
+    const installed = installImageAnalysisMcpServer();
+    const configured = installed && ensureImageAnalysisMcpConfig();
+    return installed && configured;
+}
+exports.ensureImageAnalysisMcp = ensureImageAnalysisMcp;
+function syncImageAnalysisMcpToConfigDir(claudeConfigDir) {
+    if (!claudeConfigDir) {
+        return false;
+    }
+    return new instance_manager_1.InstanceManager().syncMcpServers(claudeConfigDir);
+}
+exports.syncImageAnalysisMcpToConfigDir = syncImageAnalysisMcpToConfigDir;
+function uninstallImageAnalysisMcpServer() {
+    const artifactPaths = [getImageAnalysisMcpServerPath(), getImageAnalysisMcpRuntimePath()];
+    if (!artifactPaths.some((artifactPath) => fs.existsSync(artifactPath))) {
+        return false;
+    }
+    try {
+        let removed = false;
+        for (const artifactPath of artifactPaths) {
+            if (!fs.existsSync(artifactPath)) {
+                continue;
+            }
+            fs.unlinkSync(artifactPath);
+            removed = true;
+        }
+        return removed;
+    }
+    catch (error) {
+        if (process.env.CCS_DEBUG) {
+            console.error((0, ui_1.warn)(`Failed to remove Image Analysis MCP server: ${error.message}`));
+        }
+        return false;
+    }
+}
+exports.uninstallImageAnalysisMcpServer = uninstallImageAnalysisMcpServer;
+function removeImageAnalysisMcpConfig() {
+    let removed = removeManagedServerConfig((0, claude_config_path_1.getClaudeUserConfigPath)());
+    const instanceManager = new instance_manager_1.InstanceManager();
+    for (const instanceName of instanceManager.listInstances()) {
+        const instancePath = instanceManager.getInstancePath(instanceName);
+        const instanceClaudeConfigPath = path.join(instancePath, '.claude.json');
+        removed = removeManagedServerConfig(instanceClaudeConfigPath) || removed;
+    }
+    return removed;
+}
+exports.removeImageAnalysisMcpConfig = removeImageAnalysisMcpConfig;
+function uninstallImageAnalysisMcp() {
+    const removedConfig = removeImageAnalysisMcpConfig();
+    const removedServer = uninstallImageAnalysisMcpServer();
+    return removedConfig || removedServer;
+}
+exports.uninstallImageAnalysisMcp = uninstallImageAnalysisMcp;
+function ensureImageAnalysisMcpOrThrow() {
+    const imageConfig = (0, unified_config_loader_1.getImageAnalysisConfig)();
+    if (!imageConfig.enabled) {
+        return false;
+    }
+    const ready = ensureImageAnalysisMcp();
+    if (!ready) {
+        console.error((0, ui_1.warn)('Image Analysis is enabled, but CCS could not prepare the local ImageAnalysis tool. This session will fall back to native Read.'));
+    }
+    return ready;
+}
+exports.ensureImageAnalysisMcpOrThrow = ensureImageAnalysisMcpOrThrow;
+//# sourceMappingURL=mcp-installer.js.map