@codemieai/cdk 0.1.632 → 0.1.634

package/dist/index.js

@@ -1,9 +1,9 @@
 import ora from 'ora';
 import * as crypto from 'crypto';
 import { CodeMieClient, DataSourceType, SkillVisibility } from 'codemie-sdk';
-import * as fs from 'fs';
+import * as fs12 from 'fs';
 import * as path from 'path';
-import * as yaml6 from 'yaml';
+import * as yaml7 from 'yaml';
 import 'dotenv/config';
 import pLimit from 'p-limit';
 import * as readline from 'readline';
@@ -183,7 +183,7 @@ var init_logger = __esm({
 });
 
 // src/lib/mcpSanitizer.ts
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sanitizeObject(obj, isTopLevel) {
@@ -195,12 +195,12 @@ function sanitizeObject(obj, isTopLevel) {
     if (isTopLevel && key === "mcp_connect_url" && value === "") {
       continue;
     }
-    result[key] = isPlainObject(value) ? sanitizeObject(value, false) : value;
+    result[key] = isPlainObject2(value) ? sanitizeObject(value, false) : value;
   }
   return result;
 }
 function sanitizeMcpServer(server) {
-  if (!isPlainObject(server)) {
+  if (!isPlainObject2(server)) {
     return server;
   }
   return sanitizeObject(server, true);
@@ -243,11 +243,11 @@ function normalizeToolkits(toolkits) {
     settings: normalizeIntegrationSettings(settings)
   }));
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sortKeysDeep(value) {
-  if (!isPlainObject2(value)) {
+  if (!isPlainObject3(value)) {
     return value;
   }
   const sorted = {};
@@ -262,7 +262,7 @@ function normalizeMcpServers(mcpServers) {
   }
   return mcpServers.map((mcp) => {
     const sanitized = sanitizeMcpServer(mcp);
-    if (!isPlainObject2(sanitized)) {
+    if (!isPlainObject3(sanitized)) {
       return sanitized;
     }
     return sortKeysDeep({
@@ -690,14 +690,14 @@ function sanitizeFileName(name, maxLength = 255) {
 function validateBackupDirectory(backupDir, minSpaceGB = 1) {
   try {
     const parentDir = path.dirname(backupDir);
-    if (!fs.existsSync(parentDir)) {
-      fs.mkdirSync(parentDir, { recursive: true });
+    if (!fs12.existsSync(parentDir)) {
+      fs12.mkdirSync(parentDir, { recursive: true });
     }
     const testFile = path.join(parentDir, ".write-test");
-    fs.writeFileSync(testFile, "test");
-    fs.unlinkSync(testFile);
+    fs12.writeFileSync(testFile, "test");
+    fs12.unlinkSync(testFile);
     try {
-      const stats = fs.statfsSync(parentDir);
+      const stats = fs12.statfsSync(parentDir);
       const availableGB = stats.bavail * stats.bsize / BYTES_IN_GB;
       if (availableGB < minSpaceGB) {
         throw new Error(`Insufficient disk space: ${availableGB.toFixed(2)}GB available, need ${minSpaceGB}GB`);
@@ -713,7 +713,7 @@ function validateBackupDirectory(backupDir, minSpaceGB = 1) {
 }
 function moveAtomically(tempPath, finalPath) {
   try {
-    fs.renameSync(tempPath, finalPath);
+    fs12.renameSync(tempPath, finalPath);
   } catch (error) {
     const err = error;
     if (err.code === "EEXIST") {
@@ -723,14 +723,14 @@ function moveAtomically(tempPath, finalPath) {
   }
 }
 function cleanupDirectory(dirPath) {
-  if (fs.existsSync(dirPath)) {
-    fs.rmSync(dirPath, { recursive: true, force: true });
+  if (fs12.existsSync(dirPath)) {
+    fs12.rmSync(dirPath, { recursive: true, force: true });
   }
 }
 function ensureDirectoryExists(filePath) {
   const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
 }
 var BYTES_IN_GB;
@@ -869,7 +869,7 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
   let finalYamlContent = yamlConfig || "";
   if (yamlConfig) {
     try {
-      const workflowYaml = yaml6.parse(yamlConfig);
+      const workflowYaml = yaml7.parse(yamlConfig);
       const transformedAssistants = workflowYaml.assistants?.map((assistant) => {
         if (assistant.assistant_id && typeof assistant.assistant_id === "string") {
           const assistantId = assistant.assistant_id;
@@ -886,8 +886,8 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
         const fileName = `${sanitizeFileName(workflow.name)}.yaml`;
         const filePath = path.join(backupDir, "workflows", fileName);
         ensureDirectoryExists(filePath);
-        finalYamlContent = yaml6.stringify(transformedYaml);
-        fs.writeFileSync(filePath, finalYamlContent, "utf8");
+        finalYamlContent = yaml7.stringify(transformedYaml);
+        fs12.writeFileSync(filePath, finalYamlContent, "utf8");
       }
     } catch (error) {
       logger.warn(
@@ -964,6 +964,141 @@ function namesEqual(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
 
+// src/lib/configImports.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveImports(obj, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+  if (!isPlainObject(obj)) {
+    return;
+  }
+  for (const key in obj) {
+    const value = obj[key];
+    if (isPlainObject(value) && "$import" in value) {
+      const importDirective = value;
+      const importPath = path.join(baseDir, importDirective.$import);
+      const normalizedPath = path.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const imported = loadYamlFile(importPath);
+      obj[key] = imported;
+      resolveImports(obj[key], path.dirname(importPath), visitedFiles);
+      visitedFiles.delete(normalizedPath);
+    } else if (Array.isArray(value)) {
+      obj[key] = resolveArrayImports(value, baseDir, visitedFiles);
+    } else if (isPlainObject(value)) {
+      resolveImports(value, baseDir, visitedFiles);
+    }
+  }
+}
+function resolveArrayImports(arr, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
+  const result = [];
+  for (const item of arr) {
+    if (isPlainObject(item) && "$import" in item) {
+      const importDirective = item;
+      const importPath = path.join(baseDir, importDirective.$import);
+      const normalizedPath = path.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const imported = loadYamlFile(importPath);
+      if (Array.isArray(imported)) {
+        const resolvedArray = resolveArrayImports(imported, path.dirname(importPath), visitedFiles);
+        for (const resolvedItem of resolvedArray) {
+          result.push(resolvedItem);
+        }
+      } else if (isPlainObject(imported)) {
+        result.push(imported);
+        resolveImports(imported, path.dirname(importPath), visitedFiles);
+      } else {
+        throw new TypeError(
+          `Import file ${importPath} must contain either an object or an array. Got: ${typeof imported}`
+        );
+      }
+      visitedFiles.delete(normalizedPath);
+    } else {
+      result.push(item);
+      if (isPlainObject(item)) {
+        resolveImports(item, baseDir, visitedFiles);
+      }
+    }
+  }
+  return result;
+}
+function loadYamlFile(filePath) {
+  if (!fs12.existsSync(filePath)) {
+    throw new Error(`Import file not found: ${filePath}`);
+  }
+  try {
+    const content = fs12.readFileSync(filePath, "utf8");
+    const parsed = yaml7.parse(content);
+    if (parsed === null || parsed === void 0) {
+      throw new TypeError(`Import file ${filePath} is empty`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to parse YAML file ${filePath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function findResourceDefinition(rootDir, codemieConfigPath, plural, name) {
+  const configPath = path.join(rootDir, codemieConfigPath);
+  const config = loadYamlFile(configPath);
+  if (!isPlainObject(config) || !isPlainObject(config.resources)) {
+    return void 0;
+  }
+  const list = config.resources[plural];
+  if (!Array.isArray(list)) {
+    return void 0;
+  }
+  return findResourceInList(list, rootDir, null, name, /* @__PURE__ */ new Set());
+}
+function findResourceInList(items, baseDir, currentFile, name, visitedFiles) {
+  for (const item of items) {
+    if (!isPlainObject(item)) {
+      continue;
+    }
+    if (typeof item.$import === "string") {
+      const importPath = path.join(baseDir, item.$import);
+      const normalizedPath = path.resolve(importPath);
+      if (visitedFiles.has(normalizedPath)) {
+        throw new Error(
+          `Circular import detected: ${normalizedPath}
+Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
+        );
+      }
+      visitedFiles.add(normalizedPath);
+      const loaded = loadYamlFile(importPath);
+      let found;
+      if (Array.isArray(loaded)) {
+        found = findResourceInList(loaded, path.dirname(importPath), normalizedPath, name, visitedFiles);
+      } else if (isPlainObject(loaded) && typeof loaded.name === "string" && namesEqual(loaded.name, name)) {
+        found = { file: normalizedPath, resource: loaded, inList: false };
+      }
+      visitedFiles.delete(normalizedPath);
+      if (found) {
+        return found;
+      }
+      continue;
+    }
+    if (typeof item.name === "string" && namesEqual(item.name, name)) {
+      return { file: currentFile, resource: item, inList: true };
+    }
+  }
+  return void 0;
+}
+
 // src/lib/codemieConfigLoader.ts
 var CodemieConfigLoader = class {
   appConfig;
@@ -976,12 +1111,12 @@ var CodemieConfigLoader = class {
   loadConfig() {
     const { rootDir, codemieConfig } = this.appConfig;
     const configPath = path.join(rootDir, codemieConfig);
-    if (!fs.existsSync(configPath)) {
+    if (!fs12.existsSync(configPath)) {
       throw new Error(`Configuration file not found: ${configPath}`);
     }
-    const content = fs.readFileSync(configPath, "utf8");
-    const config = yaml6.parse(content);
-    this.resolveImports(config, rootDir);
+    const content = fs12.readFileSync(configPath, "utf8");
+    const config = yaml7.parse(content);
+    resolveImports(config, rootDir);
     this.substituteEnvVars(config);
     this.applyDatasourceDefaults(config);
     this.resolveReferencesRecursive(config, config);
@@ -994,10 +1129,10 @@ var CodemieConfigLoader = class {
   loadPrompt(promptPath) {
     const { rootDir } = this.appConfig;
     const fullPath = path.join(rootDir, promptPath);
-    if (!fs.existsSync(fullPath)) {
+    if (!fs12.existsSync(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    return fs.readFileSync(fullPath, "utf8");
+    return fs12.readFileSync(fullPath, "utf8");
   }
   /**
    * Load skill content file (.skill.md)
@@ -1005,10 +1140,10 @@ var CodemieConfigLoader = class {
   loadSkillContent(contentPath) {
     const { rootDir } = this.appConfig;
     const fullPath = path.join(rootDir, contentPath);
-    if (!fs.existsSync(fullPath)) {
+    if (!fs12.existsSync(fullPath)) {
       throw new Error(`Skill content file not found: ${fullPath}`);
     }
-    return fs.readFileSync(fullPath, "utf8");
+    return fs12.readFileSync(fullPath, "utf8");
   }
   /**
    * Load assistant configuration file
@@ -1016,11 +1151,11 @@ var CodemieConfigLoader = class {
   loadAssistantConfig(configPath) {
     const { rootDir } = this.appConfig;
     const fullPath = path.join(rootDir, configPath);
-    if (!fs.existsSync(fullPath)) {
+    if (!fs12.existsSync(fullPath)) {
       throw new Error(`Config file not found: ${fullPath}`);
     }
-    const content = fs.readFileSync(fullPath, "utf8");
-    return yaml6.parse(content);
+    const content = fs12.readFileSync(fullPath, "utf8");
+    return yaml7.parse(content);
   }
   /**
    * Validate that all referenced files exist
@@ -1030,13 +1165,14 @@ var CodemieConfigLoader = class {
     const { rootDir } = this.appConfig;
     if (config.resources.assistants) {
       for (const assistant of config.resources.assistants) {
-        const promptPath = path.join(rootDir, assistant.prompt);
-        if (!fs.existsSync(promptPath)) {
+        if (!assistant.prompt) {
+          errors.push(`Missing 'prompt' for assistant: ${assistant.name}`);
+        } else if (!fs12.existsSync(path.join(rootDir, assistant.prompt))) {
           errors.push(`Prompt file not found for ${assistant.name}: ${assistant.prompt}`);
         }
         if (assistant.config) {
           const configPath = path.join(rootDir, assistant.config);
-          if (!fs.existsSync(configPath)) {
+          if (!fs12.existsSync(configPath)) {
             errors.push(`Config file not found for ${assistant.name}: ${assistant.config}`);
           }
         }
@@ -1050,8 +1186,9 @@ var CodemieConfigLoader = class {
     }
     if (config.resources.skills) {
       for (const skill of config.resources.skills) {
-        const contentPath = path.join(rootDir, skill.file);
-        if (!fs.existsSync(contentPath)) {
+        if (!skill.file) {
+          errors.push(`Missing 'file' for skill: ${skill.name}`);
+        } else if (!fs12.existsSync(path.join(rootDir, skill.file))) {
           errors.push(`Content file not found for skill ${skill.name}: ${skill.file}`);
         }
         if (!skill.description) {
@@ -1072,109 +1209,6 @@ var CodemieConfigLoader = class {
       errors
     };
   }
-  /**
-   * Resolve $import directives recursively
-   * Automatically handles:
-   * 1. Single resource import (object)
-   * 2. Multiple resources import (array)
-   * 3. Mixed inline + imports
-   * Includes circular import detection to prevent infinite recursion
-   */
-  resolveImports(obj, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
-    if (!this.isPlainObject(obj)) {
-      return;
-    }
-    for (const key in obj) {
-      const value = obj[key];
-      if (this.isPlainObject(value) && "$import" in value) {
-        const importDirective = value;
-        const importPath = path.join(baseDir, importDirective.$import);
-        const normalizedPath = path.resolve(importPath);
-        if (visitedFiles.has(normalizedPath)) {
-          throw new Error(
-            `Circular import detected: ${normalizedPath}
-Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
-          );
-        }
-        visitedFiles.add(normalizedPath);
-        const imported = this.loadYamlFile(importPath);
-        obj[key] = imported;
-        this.resolveImports(obj[key], path.dirname(importPath), visitedFiles);
-        visitedFiles.delete(normalizedPath);
-      } else if (Array.isArray(value)) {
-        obj[key] = this.resolveArrayImports(value, baseDir, visitedFiles);
-      } else if (this.isPlainObject(value)) {
-        this.resolveImports(value, baseDir, visitedFiles);
-      }
-    }
-  }
-  /**
-   * Resolve imports in arrays
-   * Intelligently handles:
-   * - Inline objects (keep as-is)
-   * - $import with single object (add to array)
-   * - $import with array (flatten into parent array)
-   * Includes circular import detection
-   */
-  resolveArrayImports(arr, baseDir, visitedFiles = /* @__PURE__ */ new Set()) {
-    const result = [];
-    for (const item of arr) {
-      if (this.isPlainObject(item) && "$import" in item) {
-        const importDirective = item;
-        const importPath = path.join(baseDir, importDirective.$import);
-        const normalizedPath = path.resolve(importPath);
-        if (visitedFiles.has(normalizedPath)) {
-          throw new Error(
-            `Circular import detected: ${normalizedPath}
-Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
-          );
-        }
-        visitedFiles.add(normalizedPath);
-        const imported = this.loadYamlFile(importPath);
-        if (Array.isArray(imported)) {
-          const resolvedArray = this.resolveArrayImports(imported, path.dirname(importPath), visitedFiles);
-          for (const resolvedItem of resolvedArray) {
-            result.push(resolvedItem);
-          }
-        } else if (this.isPlainObject(imported)) {
-          result.push(imported);
-          this.resolveImports(imported, path.dirname(importPath), visitedFiles);
-        } else {
-          throw new TypeError(
-            `Import file ${importPath} must contain either an object or an array. Got: ${typeof imported}`
-          );
-        }
-        visitedFiles.delete(normalizedPath);
-      } else {
-        result.push(item);
-        if (this.isPlainObject(item)) {
-          this.resolveImports(item, baseDir, visitedFiles);
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Load YAML file with error handling
-   */
-  loadYamlFile(filePath) {
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Import file not found: ${filePath}`);
-    }
-    try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const parsed = yaml6.parse(content);
-      if (parsed === null || parsed === void 0) {
-        throw new TypeError(`Import file ${filePath} is empty`);
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new TypeError(`Failed to parse YAML file ${filePath}: ${error.message}`);
-      }
-      throw error;
-    }
-  }
   /**
    * Recursively resolve all $ref in an object/array structure
    * Handles both object references { $ref: "path" } and string references "$ref:path"
@@ -1183,28 +1217,28 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * @param rootConfig - Root config object (constant reference for resolving paths like "imported.integrations.xxx")
    * @param path - Current path in config tree (for error messages, e.g., "resources.assistants[0].toolkits")
    */
-  resolveReferencesRecursive(current, rootConfig, path12 = "") {
+  resolveReferencesRecursive(current, rootConfig, path13 = "") {
     if (!current || typeof current !== "object") {
       return;
     }
     if (Array.isArray(current)) {
-      this.resolveArrayReferences(current, rootConfig, path12);
+      this.resolveArrayReferences(current, rootConfig, path13);
       return;
     }
     if ("$ref" in current && typeof current.$ref === "string") {
-      this.resolveObjectReference(current, rootConfig, path12);
+      this.resolveObjectReference(current, rootConfig, path13);
       return;
     }
-    this.resolveObjectProperties(current, rootConfig, path12);
+    this.resolveObjectProperties(current, rootConfig, path13);
   }
   /**
    * Resolve $ref items in arrays and flatten if they point to arrays
    * Example: [{ $ref: "context_definitions.repos" }] where repos is [item1, item2]
    * becomes [item1, item2]
    */
-  resolveArrayReferences(arr, rootConfig, path12) {
+  resolveArrayReferences(arr, rootConfig, path13) {
     const result = arr.flatMap((item, i) => {
-      const contextPath = `${path12}[${i}]`;
+      const contextPath = `${path13}[${i}]`;
       if (!this.isRefObject(item) || item.$ref.startsWith("#")) {
         this.resolveReferencesRecursive(item, rootConfig, contextPath);
         return [item];
@@ -1222,9 +1256,9 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * Resolve object reference: { $ref: "path" }
    * Replaces object with resolved data (in-place mutation)
    */
-  resolveObjectReference(current, rootConfig, path12) {
+  resolveObjectReference(current, rootConfig, path13) {
     const refPath = current.$ref;
-    const contextPath = path12 || "root";
+    const contextPath = path13 || "root";
     if (refPath.startsWith("#")) {
       return;
     }
@@ -1234,24 +1268,24 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       delete current[key];
     }
     Object.assign(current, filteredResolved);
-    this.resolveReferencesRecursive(current, rootConfig, path12);
+    this.resolveReferencesRecursive(current, rootConfig, path13);
   }
   /**
    * Resolve object properties recursively
    * Handles both nested objects and "$ref:path" string references
    */
-  resolveObjectProperties(current, rootConfig, path12) {
+  resolveObjectProperties(current, rootConfig, path13) {
     for (const [key, value] of Object.entries(current)) {
       if (typeof value === "string" && value.startsWith("$ref:")) {
         const refPath = value.slice(5);
         if (refPath.startsWith("#")) {
           continue;
         }
-        const contextPath = path12 ? `${path12}.${key}` : key;
+        const contextPath = path13 ? `${path13}.${key}` : key;
         const resolved = this.resolveReference(rootConfig, refPath, contextPath);
         current[key] = resolved;
       } else {
-        this.resolveReferencesRecursive(value, rootConfig, path12 ? `${path12}.${key}` : key);
+        this.resolveReferencesRecursive(value, rootConfig, path13 ? `${path13}.${key}` : key);
       }
     }
   }
@@ -1411,10 +1445,10 @@ var StateManager = class {
    * Load state file
    */
   loadState() {
-    if (!fs.existsSync(this.statePath)) {
+    if (!fs12.existsSync(this.statePath)) {
       return this.createEmptyState();
     }
-    const content = fs.readFileSync(this.statePath, "utf8");
+    const content = fs12.readFileSync(this.statePath, "utf8");
     const state = JSON.parse(content);
     if (!state.resources) {
       state.resources = {
@@ -1443,11 +1477,11 @@ var StateManager = class {
    */
   saveState(state) {
     const dir = path.dirname(this.statePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
     state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
-    fs.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    fs12.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
   }
   /**
    * Create empty state structure
@@ -2653,11 +2687,11 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
     try {
       logger.info(`Processing: ${workflow.name}`);
       const yamlPath = path.join(rootDir, workflow.definition);
-      if (!fs.existsSync(yamlPath)) {
+      if (!fs12.existsSync(yamlPath)) {
         throw new Error(`Workflow definition file not found: ${workflow.definition}`);
       }
-      const yamlConfigContent = fs.readFileSync(yamlPath, "utf8");
-      const workflowYaml = yaml6.parse(yamlConfigContent);
+      const yamlConfigContent = fs12.readFileSync(yamlPath, "utf8");
+      const workflowYaml = yaml7.parse(yamlConfigContent);
       const referencesToResolve = [];
       for (const assistant of workflowYaml.assistants ?? []) {
         const isInline = !assistant.assistant_name && assistant.model && assistant.system_prompt;
@@ -2698,7 +2732,7 @@ async function deployWorkflows(config, client, stateManager, rootDir = process.c
           });
         }
       }
-      const yamlConfig = yaml6.stringify(workflowYaml);
+      const yamlConfig = yaml7.stringify(workflowYaml);
       const workflowYamlChecksum = calculateChecksum(yamlConfigContent);
       const configChecksum = calculateWorkflowConfigChecksum(workflow);
       const existingState = stateManager.getWorkflowState(workflow.name);
@@ -2922,10 +2956,10 @@ var DependencyValidator = class {
     const errors = [];
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const dfs = (name, path12) => {
+    const dfs = (name, path13) => {
       if (recursionStack.has(name)) {
-        const cycleStart = path12.indexOf(name);
-        const cycle = [...path12.slice(cycleStart), name];
+        const cycleStart = path13.indexOf(name);
+        const cycle = [...path13.slice(cycleStart), name];
         errors.push(`Cyclic dependency detected: ${cycle.join(" \u2192 ")}`);
         return true;
       }
@@ -2934,14 +2968,14 @@ var DependencyValidator = class {
       }
       visited.add(name);
       recursionStack.add(name);
-      path12.push(name);
+      path13.push(name);
       const assistant = assistantMap.get(name);
       const subAssistantRefs = assistant?.sub_assistants || [];
       for (const subRef of subAssistantRefs) {
         if (!assistantMap.has(subRef)) {
           continue;
         }
-        if (dfs(subRef, [...path12])) {
+        if (dfs(subRef, [...path13])) {
           return true;
         }
       }
@@ -3000,7 +3034,7 @@ var DependencyValidator = class {
     }
     for (const workflow of workflows) {
       try {
-        const workflowYaml = yaml6.parse(workflow.definition);
+        const workflowYaml = yaml7.parse(workflow.definition);
         if (!workflowYaml.assistants) {
           continue;
         }
@@ -3141,11 +3175,11 @@ async function validateConfig(options) {
   if (config.resources.workflows && config.resources.workflows.length > 0) {
     const workflowsWithContent = config.resources.workflows.map((workflow) => {
       const workflowPath = path.resolve(workflow.definition);
-      if (!fs.existsSync(workflowPath)) {
+      if (!fs12.existsSync(workflowPath)) {
         errors.push(`Workflow definition file not found: ${workflow.definition}`);
         return { ...workflow, definition: "" };
       }
-      const definition = fs.readFileSync(workflowPath, "utf8");
+      const definition = fs12.readFileSync(workflowPath, "utf8");
       return { ...workflow, definition };
     });
     const workflowErrors = DependencyValidator.validateWorkflowAssistantReferences(
@@ -3396,10 +3430,10 @@ async function previewWorkflows(workflows, stateManager, client, rootDir = proce
   const staleDetails = `ID from state not found; will adopt a same-name workflow${projectClause} if one exists, otherwise create`;
   for (const workflow of workflows) {
     const yamlPath = path.join(rootDir, workflow.definition);
-    if (!fs.existsSync(yamlPath)) {
+    if (!fs12.existsSync(yamlPath)) {
       throw new Error(`Workflow definition file not found: ${workflow.definition}`);
     }
-    const yamlConfig = fs.readFileSync(yamlPath, "utf8");
+    const yamlConfig = fs12.readFileSync(yamlPath, "utf8");
     const change = await previewResource(
       workflow,
       "workflow",
@@ -3512,7 +3546,7 @@ var BackupTransaction = class {
   constructor(backupDir, transactionId) {
     this.transactionPath = path.join(backupDir, "transaction.json");
     try {
-      const content = fs.readFileSync(this.transactionPath, "utf8");
+      const content = fs12.readFileSync(this.transactionPath, "utf8");
       this.data = JSON.parse(content);
       logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id}`);
     } catch (error) {
@@ -3544,9 +3578,9 @@ var BackupTransaction = class {
   }
   writeTransactionExclusively(data) {
     try {
-      const fd = fs.openSync(this.transactionPath, "wx");
-      fs.writeSync(fd, JSON.stringify(data, null, 2));
-      fs.closeSync(fd);
+      const fd = fs12.openSync(this.transactionPath, "wx");
+      fs12.writeSync(fd, JSON.stringify(data, null, 2));
+      fs12.closeSync(fd);
     } catch (writeError) {
       const writeErr = writeError;
       if (writeErr.code === "EEXIST") {
@@ -3565,7 +3599,7 @@ var BackupTransaction = class {
         if (delayMs > 0) {
           busyWaitDelay(delayMs);
         }
-        const content = fs.readFileSync(this.transactionPath, "utf8");
+        const content = fs12.readFileSync(this.transactionPath, "utf8");
         this.data = JSON.parse(content);
         logger.info(`\u{1F4C2} Resuming backup transaction ${this.data.id} (created by concurrent process)`);
         break;
@@ -3588,7 +3622,7 @@ var BackupTransaction = class {
    */
   async save() {
     ensureDirectoryExists(this.transactionPath);
-    const savePromise = fs.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    const savePromise = fs12.promises.writeFile(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
     let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(
@@ -3614,7 +3648,7 @@ var BackupTransaction = class {
    */
   saveSyncInternal() {
     ensureDirectoryExists(this.transactionPath);
-    fs.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
+    fs12.writeFileSync(this.transactionPath, JSON.stringify(this.data, null, 2), "utf8");
     this.isDirty = false;
   }
   /**
@@ -3725,8 +3759,8 @@ var BackupTransaction = class {
    * Clean up transaction file after successful completion
    */
   cleanup() {
-    if (fs.existsSync(this.transactionPath)) {
-      fs.unlinkSync(this.transactionPath);
+    if (fs12.existsSync(this.transactionPath)) {
+      fs12.unlinkSync(this.transactionPath);
     }
   }
 };
@@ -3816,7 +3850,7 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
       }
     }
   };
-  return yaml6.stringify(config);
+  return yaml7.stringify(config);
 }
 function saveIntegrationOpenApiSpecs(backupData, backupDir) {
   const specsDir = path.join(backupDir, "openapi_specs");
@@ -3832,8 +3866,8 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
     if (specEntry && typeof specEntry.value === "string" && specEntry.value) {
       const alias = integration.alias || integration.id;
       const fileName = String(alias).toLowerCase().replaceAll(/[^a-z0-9]+/g, "-");
-      if (!fs.existsSync(specsDir)) {
-        fs.mkdirSync(specsDir, { recursive: true });
+      if (!fs12.existsSync(specsDir)) {
+        fs12.mkdirSync(specsDir, { recursive: true });
       }
       const specContent = specEntry.value;
       let fileExtension = ".yaml";
@@ -3847,7 +3881,7 @@ function saveIntegrationOpenApiSpecs(backupData, backupDir) {
       }
       const specFileName = `${fileName}${fileExtension}`;
       const specPath = path.join(specsDir, specFileName);
-      fs.writeFileSync(specPath, contentToSave, "utf8");
+      fs12.writeFileSync(specPath, contentToSave, "utf8");
       integrationSpecPaths.set(integration.id, `openapi_specs/${specFileName}`);
       specsCount++;
     }
@@ -3862,13 +3896,13 @@ function saveBackupFiles(backupData, backupDir, projectName) {
   const integrationSpecPaths = saveIntegrationOpenApiSpecs(backupData, backupDir);
   const codemieYamlPath = path.join(backupDir, "codemie.yaml");
   const codemieYaml = generateCodemieYaml(backupData, projectName, backupDir, integrationSpecPaths);
-  fs.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
+  fs12.writeFileSync(codemieYamlPath, codemieYaml, "utf8");
   logger.info(`   \u2713 Saved config file: codemie.yaml`);
   const backupJsonPath = path.join(backupDir, "backup.json");
-  fs.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
+  fs12.writeFileSync(backupJsonPath, JSON.stringify(backupData, null, 2), "utf8");
   logger.info(`   \u2713 Saved full backup: backup.json`);
   const statePath = path.join(backupDir, "state.json");
-  fs.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
+  fs12.writeFileSync(statePath, JSON.stringify(backupData.state, null, 2), "utf8");
   logger.info(`   \u2713 Saved state file: state.json`);
 }
 
@@ -3978,7 +4012,7 @@ async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
     const fileName = `${full.slug || sanitizeFileName(full.name)}.prompt.md`;
     const filePath = path.join(backupDir, "system_prompts", fileName);
     ensureDirectoryExists(filePath);
-    fs.writeFileSync(filePath, full.system_prompt, "utf8");
+    fs12.writeFileSync(filePath, full.system_prompt, "utf8");
   }
 }
 async function backupAssistants(client, backupData, backupDir, transaction) {
@@ -4106,7 +4140,7 @@ async function backupWorkflows(client, backupData, backupDir, transaction) {
         const fileName = `${sanitizeFileName(full.name)}.yaml`;
         const filePath = path.join(backupDir, "workflows", fileName);
         ensureDirectoryExists(filePath);
-        fs.writeFileSync(filePath, full.yaml_config, "utf8");
+        fs12.writeFileSync(filePath, full.yaml_config, "utf8");
       }
       transaction.markCompleted("workflows", workflow.id);
     } catch (error) {
@@ -4211,7 +4245,7 @@ async function backupSkills(client, backupData, backupDir, transaction, projectN
             const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
             const filePath = path.join(backupDir, "skills", fileName);
             ensureDirectoryExists(filePath);
-            fs.writeFileSync(filePath, full.content || "", "utf8");
+            fs12.writeFileSync(filePath, full.content || "", "utf8");
           } else {
             logger.info(`     \u21B7 Skipping content file for imported skill ${skill.name} (owner: ${full.project})`);
           }
@@ -4234,7 +4268,7 @@ async function backupSkills(client, backupData, backupDir, transaction, projectN
 function getUniqueBackupDir(baseDir, timestamp) {
   let counter = 0;
   let finalBackupDir = path.join(baseDir, timestamp);
-  while (fs.existsSync(finalBackupDir)) {
+  while (fs12.existsSync(finalBackupDir)) {
     counter++;
     finalBackupDir = path.join(baseDir, `${timestamp}-${counter}`);
   }
@@ -4243,7 +4277,7 @@ function getUniqueBackupDir(baseDir, timestamp) {
   return { finalDir: finalBackupDir, tempDir: tempBackupDir };
 }
 function performCleanup(tempBackupDir, transaction) {
-  if (fs.existsSync(tempBackupDir)) {
+  if (fs12.existsSync(tempBackupDir)) {
     try {
       logger.info(`\u{1F9F9} Rolling back: cleaning up ${tempBackupDir}...`);
       cleanupDirectory(tempBackupDir);
@@ -4282,8 +4316,8 @@ async function backupResources(options) {
     logger.info("\u{1F50C} Connecting to Codemie API...");
     const client = await createClient(config);
     logger.info("\u2713 Connected to Codemie API\n");
-    if (!fs.existsSync(tempBackupDir)) {
-      fs.mkdirSync(tempBackupDir, { recursive: true });
+    if (!fs12.existsSync(tempBackupDir)) {
+      fs12.mkdirSync(tempBackupDir, { recursive: true });
     }
     logger.info(`\u{1F4C1} Temporary backup directory: ${tempBackupDir}
 `);
@@ -4364,14 +4398,34 @@ async function backupResources(options) {
 }
 
 // src/import.ts
+init_checksumUtils();
+init_codemieConfigChecksums();
 init_converters();
-init_skillUtils();
 init_fileUtils();
 init_logger();
-init_checksumUtils();
-init_codemieConfigChecksums();
+
+// src/lib/resourceTypes.ts
 var VALID_RESOURCE_TYPES = ["assistant", "datasource", "workflow", "skill"];
+var PLURAL_BY_RESOURCE_TYPE = {
+  assistant: "assistants",
+  datasource: "datasources",
+  workflow: "workflows",
+  skill: "skills"
+};
+function pluralTypeOf(resourceType) {
+  return PLURAL_BY_RESOURCE_TYPE[resourceType];
+}
+
+// src/import.ts
+init_skillUtils();
 async function findAssistant(client, slug) {
+  if (UUID_RE.test(slug)) {
+    return withTimeout(
+      client.assistants.get(slug),
+      TIMEOUTS_MS.ASSISTANT_FETCH,
+      `Timeout fetching assistant "${slug}"`
+    );
+  }
   try {
     const assistant = await withTimeout(
       client.assistants.getBySlug(slug),
@@ -4455,7 +4509,7 @@ Please use a more specific name.`);
   return matches[0];
 }
 function checkResourceExists2(config, resourceType, name) {
-  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : resourceType === "workflow" ? "workflows" : "skills";
+  const pluralType = pluralTypeOf(resourceType);
   const resources = config.resources[pluralType] || [];
   if (resources.some((r) => namesEqual(r.name, name))) {
     return true;
@@ -4466,8 +4520,38 @@ function checkResourceExists2(config, resourceType, name) {
   }
   return false;
 }
+function findManagedNameById(stateManager, resourceType, id) {
+  const state = stateManager.loadState();
+  const pluralType = pluralTypeOf(resourceType);
+  const resources = state.resources[pluralType] || {};
+  const matches = Object.keys(resources).filter((name) => resources[name]?.id === id);
+  if (matches.length > 1) {
+    throw new Error(
+      `state.json is ambiguous: ${matches.length} ${pluralType} entries share platform id ${id} (${matches.map((name) => `"${name}"`).join(", ")}). Remove the duplicate entries so this ${resourceType} can be matched unambiguously.`
+    );
+  }
+  return matches[0];
+}
+function nameClashError(resourceType, name) {
+  return new Error(
+    `A ${resourceType} named "${name}" already exists in the configuration. Re-run with --update to replace it with the platform version, or remove it first.`
+  );
+}
+function assertResolvedNameIsFree(config, stateManager, resourceType, slug, resolvedName, id, update) {
+  if (!update && !namesEqual(slug, resolvedName) && checkResourceExists2(config, resourceType, resolvedName)) {
+    throw nameClashError(resourceType, resolvedName);
+  }
+  const managedName = findManagedNameById(stateManager, resourceType, id);
+  if (!update && managedName !== void 0 && !namesEqual(managedName, resolvedName)) {
+    throw new Error(
+      `This ${resourceType} (id ${id}) is already managed by this project under the name "${managedName}", but is now named "${resolvedName}" on the platform.`
+    );
+  }
+  return managedName;
+}
 function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
   const safeName = sanitizeFileName(resource.name);
+  const target = resource;
   if (resourceType === "workflow") {
     const workflow = apiResponse;
     const workflowResource = resource;
@@ -4475,19 +4559,21 @@ function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
       const defFileName = `${safeName}.yaml`;
       const defPath = path.join(rootDir, "workflows", defFileName);
       ensureDirectoryExists(defPath);
-      fs.writeFileSync(defPath, workflow.yaml_config, "utf8");
+      fs12.writeFileSync(defPath, workflow.yaml_config, "utf8");
       logger.info(`   \u{1F4CB} Saved workflow definition: workflows/${defFileName}`);
       workflowResource.definition = `workflows/${defFileName}`;
+    } else {
+      delete target.definition;
     }
     const configPath = path.join(rootDir, "configs", "workflows", `${safeName}.yaml`);
     const relativeConfigPath = `configs/workflows/${safeName}.yaml`;
     ensureDirectoryExists(configPath);
-    const yamlContent2 = yaml6.stringify(workflowResource, { lineWidth: 120 });
-    fs.writeFileSync(configPath, yamlContent2, "utf8");
+    const yamlContent2 = yaml7.stringify(workflowResource, { lineWidth: 120 });
+    fs12.writeFileSync(configPath, yamlContent2, "utf8");
     logger.info(`   \u{1F4C4} Saved workflow config: ${relativeConfigPath}`);
     return relativeConfigPath;
   }
-  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : "skills";
+  const pluralType = pluralTypeOf(resourceType);
   const resourceDir = path.join(rootDir, "configs", "imported-resources", pluralType);
   const resourceFilePath = path.join(resourceDir, `${safeName}.yaml`);
   const relativeResourcePath = `configs/imported-resources/${pluralType}/${safeName}.yaml`;
@@ -4498,9 +4584,11 @@ function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
       const promptFileName = assistant.slug || safeName;
       const promptPath = path.join(rootDir, "system_prompts", `${promptFileName}.prompt.md`);
       ensureDirectoryExists(promptPath);
-      fs.writeFileSync(promptPath, assistant.system_prompt, "utf8");
+      fs12.writeFileSync(promptPath, assistant.system_prompt, "utf8");
       logger.info(`   \u{1F4DD} Saved prompt: system_prompts/${promptFileName}.prompt.md`);
       assistantResource.prompt = `system_prompts/${promptFileName}.prompt.md`;
+    } else {
+      delete target.prompt;
     }
   } else if (resourceType === "skill") {
     const skill = apiResponse;
@@ -4509,25 +4597,175 @@ function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
       const skillFileName = `${safeName}.skill.md`;
       const skillPath = path.join(rootDir, "skills", skillFileName);
       ensureDirectoryExists(skillPath);
-      fs.writeFileSync(skillPath, skill.content, "utf8");
+      fs12.writeFileSync(skillPath, skill.content, "utf8");
       logger.info(`   \u{1F9E0} Saved skill content: skills/${skillFileName}`);
       skillResource.file = `skills/${skillFileName}`;
+    } else {
+      delete target.file;
     }
   }
   ensureDirectoryExists(resourceFilePath);
-  const yamlContent = yaml6.stringify(resource, { lineWidth: 120 });
-  fs.writeFileSync(resourceFilePath, yamlContent, "utf8");
+  const yamlContent = yaml7.stringify(resource, { lineWidth: 120 });
+  fs12.writeFileSync(resourceFilePath, yamlContent, "utf8");
   logger.info(`   \u{1F4C4} Saved resource config: ${relativeResourcePath}`);
   return relativeResourcePath;
 }
+function planCompanionWrite(rootDir, target, key, configuredValue, content, defaultPath, label) {
+  const configuredPath = typeof configuredValue === "string" ? configuredValue : void 0;
+  if (!content) {
+    if (configuredPath === void 0) {
+      delete target[key];
+    } else {
+      target[key] = configuredPath;
+    }
+    return void 0;
+  }
+  const relPath = configuredPath ?? defaultPath;
+  target[key] = relPath;
+  return { absPath: path.join(rootDir, relPath), content, log: `   ${label}: ${relPath}` };
+}
+var IN_LIST_ITEM_INDENT = 2;
+function itemCarriesAnchorAliasOrMergeKey(node) {
+  if (node.anchor !== void 0) {
+    return true;
+  }
+  return node.items.some((pair) => {
+    const key = pair.key;
+    const keyValue = yaml7.isScalar(key) ? key.value : key;
+    if (keyValue === "<<") {
+      return true;
+    }
+    const value = pair.value;
+    if (yaml7.isAlias(value)) {
+      return true;
+    }
+    return yaml7.isNode(value) && value.anchor !== void 0;
+  });
+}
+function spliceResourceIntoList(filePath, relativeResourcePath, resource, existingName) {
+  const source = fs12.readFileSync(filePath, "utf8");
+  const doc = yaml7.parseDocument(source);
+  const refusal = (reason) => new Error(
+    `Cannot safely update "${existingName}" inside ${relativeResourcePath}: ${reason}. Update ${relativeResourcePath} manually.`
+  );
+  if (!yaml7.isSeq(doc.contents) || doc.contents.flow) {
+    throw refusal("the file is not a block-style YAML sequence");
+  }
+  const node = doc.contents.items.find((item) => {
+    if (!yaml7.isMap(item)) {
+      return false;
+    }
+    const itemName = item.get("name");
+    return typeof itemName === "string" && namesEqual(itemName, existingName);
+  });
+  if (!node?.range) {
+    throw refusal("its entry could not be located as a block mapping in the sequence");
+  }
+  if (node.flow) {
+    throw refusal("its entry uses flow style ({ ... })");
+  }
+  if (itemCarriesAnchorAliasOrMergeKey(node)) {
+    throw refusal("its entry uses a YAML anchor, alias or merge key");
+  }
+  const [start, valueEnd] = node.range;
+  const indent = start - (source.lastIndexOf("\n", start - 1) + 1);
+  if (indent !== IN_LIST_ITEM_INDENT) {
+    throw refusal(`its entry is indented by ${indent} spaces instead of ${IN_LIST_ITEM_INDENT}`);
+  }
+  const rendered = yaml7.stringify(resource, { lineWidth: 120 }).trimEnd();
+  const replacement = rendered.split("\n").map((line, index) => index === 0 || !line ? line : `${" ".repeat(IN_LIST_ITEM_INDENT)}${line}`).join("\n");
+  const tail = source.slice(valueEnd);
+  const separator = tail.startsWith("\n") ? "" : "\n";
+  return source.slice(0, start) + replacement + separator + tail;
+}
+function updateResourceFiles(rootDir, resourceType, resource, apiResponse, existing) {
+  const filePath = existing.file;
+  if (!filePath) {
+    throw new Error("updateResourceFiles requires an existing resource backed by a file");
+  }
+  const existingResource = existing.resource;
+  const target = resource;
+  const safeName = sanitizeFileName(resource.name);
+  for (const [key, value] of Object.entries(existingResource)) {
+    if (key === "skill_ids" || key in target) {
+      continue;
+    }
+    target[key] = value;
+  }
+  let companion;
+  if (resourceType === "assistant") {
+    const assistant = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "prompt",
+      existingResource.prompt,
+      assistant.system_prompt,
+      `system_prompts/${assistant.slug || safeName}.prompt.md`,
+      "\u{1F4DD} Updated prompt"
+    );
+  } else if (resourceType === "skill") {
+    const skill = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "file",
+      existingResource.file,
+      skill.content,
+      `skills/${safeName}.skill.md`,
+      "\u{1F9E0} Updated skill content"
+    );
+  } else if (resourceType === "workflow") {
+    const workflow = apiResponse;
+    companion = planCompanionWrite(
+      rootDir,
+      target,
+      "definition",
+      existingResource.definition,
+      workflow.yaml_config,
+      `workflows/${safeName}.yaml`,
+      "\u{1F4CB} Updated workflow definition"
+    );
+  }
+  const relativeResourcePath = path.relative(rootDir, filePath);
+  const newResourceFileContent = existing.inList ? spliceResourceIntoList(filePath, relativeResourcePath, resource, String(existingResource.name)) : yaml7.stringify(resource, { lineWidth: 120 });
+  if (companion) {
+    ensureDirectoryExists(companion.absPath);
+    fs12.writeFileSync(companion.absPath, companion.content, "utf8");
+    logger.info(companion.log);
+  }
+  fs12.writeFileSync(filePath, newResourceFileContent, "utf8");
+  logger.info(`   \u{1F4C4} Updated resource config: ${relativeResourcePath}`);
+  return relativeResourcePath;
+}
+function deleteStateEntry(stateManager, resourceType, name) {
+  switch (resourceType) {
+    case "assistant": {
+      stateManager.deleteAssistantState(name);
+      break;
+    }
+    case "datasource": {
+      stateManager.deleteDatasourceState(name);
+      break;
+    }
+    case "workflow": {
+      stateManager.deleteWorkflowState(name);
+      break;
+    }
+    case "skill": {
+      stateManager.deleteSkillState(name);
+      break;
+    }
+  }
+}
 function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relativeResourcePath) {
   const configPath = path.join(rootDir, codemieConfigPath);
-  if (!fs.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     throw new Error(`Configuration file not found: ${configPath}`);
   }
-  const content = fs.readFileSync(configPath, "utf8");
-  const doc = yaml6.parseDocument(content);
-  const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : resourceType === "workflow" ? "workflows" : "skills";
+  const content = fs12.readFileSync(configPath, "utf8");
+  const doc = yaml7.parseDocument(content);
+  const pluralType = pluralTypeOf(resourceType);
   let resourcesNode = doc.get("resources");
   if (!resourcesNode) {
     resourcesNode = doc.createNode({});
@@ -4540,7 +4778,7 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   }
   const importDirective = { $import: relativeResourcePath };
   const existingImports = typeArray.items.filter((item) => {
-    if (yaml6.isMap(item)) {
+    if (yaml7.isMap(item)) {
       const importValue = item.get("$import");
       return importValue === relativeResourcePath;
     }
@@ -4552,16 +4790,16 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   }
   const newNode = doc.createNode(importDirective);
   typeArray.add(newNode);
-  fs.writeFileSync(configPath, doc.toString(), "utf8");
+  fs12.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
 }
 function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
   const configPath = path.join(rootDir, codemieConfigPath);
-  if (!fs.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     throw new Error(`Configuration file not found: ${configPath}`);
   }
-  const content = fs.readFileSync(configPath, "utf8");
-  const doc = yaml6.parseDocument(content);
+  const content = fs12.readFileSync(configPath, "utf8");
+  const doc = yaml7.parseDocument(content);
   let importedNode = doc.get("imported");
   if (!importedNode) {
     importedNode = doc.createNode({ assistants: [], datasources: [], skills: [], integrations: [] });
@@ -4573,7 +4811,7 @@ function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
     doc.setIn(["imported", "skills"], skillsArray);
   }
   const existingSkill = skillsArray.items.find((item) => {
-    if (!yaml6.isMap(item)) {
+    if (!yaml7.isMap(item)) {
       return false;
     }
     const existingName = item.get("name");
@@ -4590,9 +4828,47 @@ function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
     return;
   }
   skillsArray.add(doc.createNode({ name: skill.name, id: skill.id }));
-  fs.writeFileSync(configPath, doc.toString(), "utf8");
+  fs12.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added skill to ${codemieConfigPath} \u2192 imported.skills`);
 }
+function updateImportedSkillInCodemieYaml(rootDir, codemieConfigPath, skill) {
+  const configPath = path.join(rootDir, codemieConfigPath);
+  if (!fs12.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs12.readFileSync(configPath, "utf8");
+  const doc = yaml7.parseDocument(content);
+  const skillsArray = doc.getIn(["imported", "skills"]);
+  if (!skillsArray) {
+    return false;
+  }
+  const items = skillsArray.items.filter((item) => yaml7.isMap(item));
+  const entryById = items.find((item) => {
+    const existingId = item.get("id");
+    return typeof existingId === "string" && existingId === skill.id;
+  });
+  const entry = entryById ?? items.find((item) => {
+    const existingName = item.get("name");
+    return typeof existingName === "string" && namesEqual(existingName, skill.name);
+  });
+  if (!entry) {
+    return false;
+  }
+  entry.set("name", skill.name);
+  entry.set("id", skill.id);
+  fs12.writeFileSync(configPath, doc.toString(), "utf8");
+  return true;
+}
+function upsertImportedSkill(rootDir, codemieConfigPath, skill, update) {
+  if (update) {
+    if (updateImportedSkillInCodemieYaml(rootDir, codemieConfigPath, skill)) {
+      logger.info(`   \u267B\uFE0F  Refreshed imported.skills entry for external skill "${skill.name}"`);
+      return;
+    }
+    logger.info(`   No existing skill found in the configuration \u2014 importing as new`);
+  }
+  addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill);
+}
 function ensureExternalSkillDoesNotConflictWithManagedSkill(config, skillName) {
   const managedSkill = config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
   if (!managedSkill) {
@@ -4645,7 +4921,7 @@ function buildIntegrationAliasMap(config) {
   return map;
 }
 async function importResource(options) {
-  const { appConfig, resourceType, slug } = options;
+  const { appConfig, resourceType, slug, update = false } = options;
   if (!VALID_RESOURCE_TYPES.includes(resourceType)) {
     throw new Error(`Invalid resource type: "${resourceType}". Must be one of: ${VALID_RESOURCE_TYPES.join(", ")}`);
   }
@@ -4653,10 +4929,8 @@ async function importResource(options) {
   const config = configLoader.loadConfig();
   const rootDir = appConfig.rootDir;
   const stateManager = new StateManager(appConfig);
-  if (checkResourceExists2(config, resourceType, slug)) {
-    throw new Error(
-      `A ${resourceType} named "${slug}" already exists in the configuration. Remove it first or use a different name.`
-    );
+  if (!update && checkResourceExists2(config, resourceType, slug)) {
+    throw nameClashError(resourceType, slug);
   }
   logger.info(`
 \u{1F50D} Importing ${resourceType}: "${slug}"
@@ -4666,11 +4940,21 @@ async function importResource(options) {
   const integrationAliasMap = buildIntegrationAliasMap(config);
   let resource;
   let apiResponse;
+  let managedName;
   switch (resourceType) {
     case "assistant": {
       logger.info(`   Searching for assistant "${slug}"...`);
       const assistant = await findAssistant(client, slug);
       logger.info(`   \u2713 Found: ${assistant.name} (${assistant.id})`);
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        assistant.name,
+        assistant.id,
+        update
+      );
       apiResponse = assistant;
       resource = assistantResponseToResource(assistant);
       if (integrationAliasMap.size > 0) {
@@ -4704,7 +4988,7 @@ async function importResource(options) {
           logger.info(`     \u2713 Resolved skill ${skillId.slice(0, 8)}... \u2192 "${skill.name}"`);
           if (!isProjectOwnedSkill(skill, config.project.name)) {
             ensureExternalSkillDoesNotConflictWithManagedSkill(config, skill.name);
-            addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
+            upsertImportedSkill(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id }, update);
           }
         }
         if (skillNames.length > 0) {
@@ -4717,6 +5001,15 @@ async function importResource(options) {
       logger.info(`   Searching for datasource "${slug}"...`);
       const datasource = await findDatasource(client, slug);
       logger.info(`   \u2713 Found: ${datasource.name} (${datasource.id})`);
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        datasource.name,
+        datasource.id,
+        update
+      );
       apiResponse = datasource;
       const settingId = datasource.setting_id || "";
       const integrationAlias = integrationAliasMap.get(settingId);
@@ -4727,11 +5020,15 @@ async function importResource(options) {
       logger.info(`   Searching for workflow "${slug}"...`);
       const workflow = await findWorkflow(client, slug);
       logger.info(`   \u2713 Found: ${workflow.name} (${workflow.id})`);
-      if (workflow.name !== slug && checkResourceExists2(config, resourceType, workflow.name)) {
-        throw new Error(
-          `A ${resourceType} named "${workflow.name}" already exists in the configuration. Remove it first or use a different name.`
-        );
-      }
+      managedName = assertResolvedNameIsFree(
+        config,
+        stateManager,
+        resourceType,
+        slug,
+        workflow.name,
+        workflow.id,
+        update
+      );
       apiResponse = workflow;
       resource = workflowResponseToResource(workflow);
       break;
@@ -4740,24 +5037,44 @@ async function importResource(options) {
       logger.info(`   Searching for skill "${slug}"...`);
       const skill = await findSkill(client, slug);
       logger.info(`   \u2713 Found: ${skill.name} (${skill.id})`);
-      if (skill.name !== slug && checkResourceExists2(config, resourceType, skill.name)) {
-        throw new Error(
-          `A ${resourceType} named "${skill.name}" already exists in the configuration. Remove it first or use a different name.`
-        );
-      }
+      managedName = assertResolvedNameIsFree(config, stateManager, resourceType, slug, skill.name, skill.id, update);
       if (isProjectOwnedSkill(skill, config.project.name)) {
         logger.info(`   Project-owned skill \u2014 importing into resources.skills`);
         apiResponse = skill;
         resource = skillResponseToResource(skill);
         break;
       }
-      addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
+      upsertImportedSkill(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id }, update);
       logger.info(`
 \u2705 Successfully imported external skill "${skill.name}" into imported.skills
 `);
       return;
     }
   }
+  if (update) {
+    const pluralType = pluralTypeOf(resourceType);
+    const lookupName = managedName ?? resource.name;
+    const existing = findResourceDefinition(rootDir, appConfig.codemieConfig, pluralType, lookupName);
+    if (existing) {
+      if (existing.file === null) {
+        throw new Error(
+          `Cannot update "${resource.name}": it is not defined in a file referenced by codemie.yaml. Update it manually.`
+        );
+      }
+      logger.info(`   \u267B\uFE0F  Updating existing ${resourceType} config in place...`);
+      updateResourceFiles(rootDir, resourceType, resource, apiResponse, existing);
+      if (managedName !== void 0 && !namesEqual(managedName, resource.name)) {
+        logger.info(`   \u{1F3F7}\uFE0F  Renamed from "${managedName}" to "${resource.name}" \u2014 updating state.json`);
+        deleteStateEntry(stateManager, resourceType, managedName);
+      }
+      updateState(stateManager, resourceType, resource, apiResponse);
+      logger.info(`
+\u2705 Successfully imported ${resourceType} "${resource.name}"
+`);
+      return;
+    }
+    logger.info(`   No existing ${resourceType} found in the configuration \u2014 importing as new`);
+  }
   const relativeResourcePath = writeResourceFiles(rootDir, resourceType, resource, apiResponse);
   addImportToCodemieYaml(rootDir, appConfig.codemieConfig, resourceType, relativeResourcePath);
   updateState(stateManager, resourceType, resource, apiResponse);