opencastle 0.5.1 → 0.7.0

package/src/cli/init.ts

@@ -1,18 +1,30 @@
 import { resolve } from 'node:path'
 import { readFile, unlink } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { select, confirm, closePrompts } from './prompt.js'
+import { multiselect, confirm, closePrompts, c } from './prompt.js'
 import { readManifest, writeManifest, createManifest } from './manifest.js'
 import { removeDirIfExists } from './copy.js'
 import { updateGitignore } from './gitignore.js'
 import { getRequiredMcpEnvVars } from './stack-config.js'
-import type { CliContext, IdeAdapter, CmsChoice, DbChoice, PmChoice, NotifChoice, StackConfig } from './types.js'
+import { TECH_PLUGINS, TEAM_PLUGINS } from '../orchestrator/plugins/index.js'
+import { detectRepoInfo, mergeStackIntoRepoInfo, formatRepoInfo } from './detect.js'
+import type { CliContext, IdeAdapter, IdeChoice, TechTool, TeamTool, StackConfig } from './types.js'
 
 const ADAPTERS: Record<string, () => Promise<IdeAdapter>> = {
   vscode: () => import('./adapters/vscode.js') as Promise<IdeAdapter>,
   cursor: () => import('./adapters/cursor.js') as Promise<IdeAdapter>,
   'claude-code': () =>
     import('./adapters/claude-code.js') as Promise<IdeAdapter>,
+  opencode: () =>
+    import('./adapters/opencode.js') as Promise<IdeAdapter>,
+}
+
+/** IDE display labels */
+const IDE_DISPLAY: Record<IdeChoice, string> = {
+  vscode: 'VS Code',
+  cursor: 'Cursor',
+  'claude-code': 'Claude Code',
+  opencode: 'OpenCode',
 }
 
 export default async function init({ pkgRoot, args }: CliContext): Promise<void> {
@@ -24,7 +36,7 @@ export default async function init({ pkgRoot, args }: CliContext): Promise<void>
   let isReinit = false
   if (existing) {
     const proceed = await confirm(
-      `OpenCastle already installed (v${existing.version}, ${existing.ide}). Re-initialize?`,
+      `OpenCastle already installed (v${existing.version}). Re-initialize?`,
       false
     )
     if (!proceed) {
@@ -38,78 +50,117 @@ export default async function init({ pkgRoot, args }: CliContext): Promise<void>
     await readFile(resolve(pkgRoot, 'package.json'), 'utf8')
   ) as { version: string }
 
-  console.log(`\n  🏰 OpenCastle v${pkg.version}`)
+  console.log(`\n  🏰 ${c.bold('OpenCastle')} ${c.dim(`v${pkg.version}`)}`)
   console.log(
-    '  Multi-agent orchestration framework for AI coding assistants\n'
+    `  ${c.dim('Multi-agent orchestration framework for AI coding assistants')}\n`
   )
 
-  // ── IDE selection ───────────────────────────────────────────────
-  const ide = await select('Which IDE are you using?', [
-    {
-      label: 'VS Code',
-      hint: 'GitHub Copilot — .github/ agents, instructions, skills',
-      value: 'vscode',
-    },
-    {
-      label: 'Cursor',
-      hint: '.cursorrules & .cursor/rules/*.mdc',
-      value: 'cursor',
-    },
-    {
-      label: 'Claude Code',
-      hint: 'CLAUDE.md & .claude/ commands, skills',
-      value: 'claude-code',
-    },
-  ])
+  // ── Repo research ───────────────────────────────────────────────
+  console.log(`  ${c.dim('Scanning repository...')}`)
+  const repoInfo = await detectRepoInfo(projectRoot)
+  const summary = formatRepoInfo(repoInfo)
+  if (summary) {
+    console.log(`  ${c.green('Detected:')}\n` + summary + '\n')
+  } else {
+    console.log(`  ${c.dim('No tooling detected (empty project?)')}\n`)
+  }
 
-  // ── CMS selection ───────────────────────────────────────────────
-  const cms = await select('Which CMS are you using?', [
-    { label: 'Sanity', hint: 'GROQ queries, real-time collaboration', value: 'sanity' },
-    { label: 'Contentful', hint: 'GraphQL / REST API, structured content', value: 'contentful' },
-    { label: 'Strapi', hint: 'Open-source headless CMS', value: 'strapi' },
-    { label: 'None', hint: 'No CMS — skip CMS skills and agents', value: 'none' },
-  ])
+  // ── IDEs (multiselect, at least 1) ─────────────────────────────
+  console.log(`  ${c.bold('── IDEs ──────────────────────────────────────')}`)
+  let ides: string[] = []
+  while (ides.length === 0) {
+    ides = await multiselect('Which IDEs do you use?', [
+      {
+        label: 'VS Code',
+        hint: 'GitHub Copilot agents, instructions, skills',
+        value: 'vscode',
+      },
+      {
+        label: 'Cursor',
+        hint: '.cursorrules & .cursor/rules/*.mdc',
+        value: 'cursor',
+      },
+      {
+        label: 'Claude Code',
+        hint: 'CLAUDE.md & .claude/ commands, skills',
+        value: 'claude-code',
+      },
+      {
+        label: 'OpenCode',
+        hint: 'AGENTS.md & opencode.json',
+        value: 'opencode',
+      },
+    ])
+    if (ides.length === 0) {
+      console.log(`  ${c.yellow('Please select at least one IDE.')}`)
+    }
+  }
 
-  // ── Database selection ──────────────────────────────────────────
-  const db = await select('Which database are you using?', [
-    { label: 'Supabase', hint: 'Postgres + Auth + RLS + Edge Functions', value: 'supabase' },
-    { label: 'Convex', hint: 'Reactive backend with real-time sync', value: 'convex' },
-    { label: 'None', hint: 'No database — skip DB skills and agents', value: 'none' },
+  // ── Tech Tools (multiselect, 0-N) ──────────────────────────────
+  // Pre-select tools already detected in the repo
+  const detectedTools = new Set([
+    ...(repoInfo.cms ?? []),
+    ...(repoInfo.databases ?? []),
+    ...(repoInfo.deployment ?? []),
+    ...(repoInfo.monorepo ? [repoInfo.monorepo] : []),
   ])
 
-  // ── Project management selection ────────────────────────────────
-  const pm = await select('Which project management tool are you using?', [
-    { label: 'Linear', hint: 'Issue tracking with MCP integration', value: 'linear' },
-    { label: 'Jira', hint: 'Atlassian issue tracking via Rovo MCP', value: 'jira' },
-    { label: 'None', hint: 'No project management — skip PM skills', value: 'none' },
-  ])
+  console.log(`  ${c.bold('── Tech Tools ────────────────────────────────')}`)
+  const techTools = await multiselect('Which tools does your project use?',
+    TECH_PLUGINS.map((p) => ({
+      label: p.label,
+      hint: p.hint,
+      value: p.id,
+      ...((p.preselected || detectedTools.has(p.id)) && { selected: true }),
+    }))
+  )
 
-  // ── Notifications selection ────────────────────────────────────
-  const notifications = await select('Which notifications tool are you using?', [
-    { label: 'Slack', hint: 'Agent notifications and bi-directional communication', value: 'slack' },
-    { label: 'Microsoft Teams', hint: 'Agent notifications via Teams channels', value: 'teams' },
-    { label: 'None', hint: 'No notifications — skip messaging skills', value: 'none' },
-  ])
+  // ── Team Tools (multiselect, 0-N) ──────────────────────────────
+  console.log(`  ${c.bold('── Team Tools ────────────────────────────────')}`)
+  const teamTools = await multiselect('Which team tools do you use?',
+    TEAM_PLUGINS.map((p) => ({
+      label: p.label,
+      hint: p.hint,
+      value: p.id,
+      ...(p.preselected && { selected: true }),
+    }))
+  )
 
-  const stack: StackConfig = { cms: cms as CmsChoice, db: db as DbChoice, pm: pm as PmChoice, notifications: notifications as NotifChoice }
+  const stack: StackConfig = {
+    ides: ides as IdeChoice[],
+    techTools: techTools as TechTool[],
+    teamTools: teamTools as TeamTool[],
+  }
 
-  console.log(`\n  Installing for ${ide}...`)
-  console.log(`  Stack: CMS=${stack.cms}, DB=${stack.db}, PM=${stack.pm}, Notifications=${stack.notifications}\n`)
+  // ── Merge user choices into detected info ────────────────────
+  const combinedRepoInfo = mergeStackIntoRepoInfo(repoInfo, stack)
+
+  const ideNames = ides.map((id) => IDE_DISPLAY[id as IdeChoice]).join(', ')
+  console.log(`\n  Installing for ${c.cyan(ideNames)}...`)
+  if (techTools.length > 0) {
+    console.log(`  Tech: ${c.green(techTools.join(', '))}`)
+  }
+  if (teamTools.length > 0) {
+    console.log(`  Team: ${c.green(teamTools.join(', '))}`)
+  }
+  console.log()
 
   // ── Dry run ─────────────────────────────────────────────────────
   if (dryRun) {
-    const adapter = await ADAPTERS[ide]()
-    const managed = adapter.getManagedPaths()
-    console.log('  [dry-run] Files that would be created:\n')
-    for (const p of managed.framework) {
-      console.log(`    + ${p}`)
-    }
-    for (const p of managed.customizable) {
-      console.log(`    + ${p}`)
+    for (const ide of ides) {
+      const adapter = await ADAPTERS[ide]()
+      const managed = adapter.getManagedPaths()
+      console.log(`  ${c.dim(`[dry-run] ${IDE_DISPLAY[ide as IdeChoice]} files:`)}\n`)
+      for (const p of managed.framework) {
+        console.log(`    ${c.green('+')} ${p}`)
+      }
+      for (const p of managed.customizable) {
+        console.log(`    ${c.green('+')} ${p}`)
+      }
     }
-    console.log(`    + .opencastle.json`)
-    console.log(`    + .gitignore (OpenCastle entries)`)
-    console.log('\n  No files were written.\n')
+    console.log(`    ${c.green('+')} .opencastle.json`)
+    console.log(`    ${c.green('+')} .gitignore (OpenCastle entries)`)
+    console.log(`\n  ${c.dim('No files were written.')}\n`)
     closePrompts()
     return
   }
@@ -125,11 +176,12 @@ export default async function init({ pkgRoot, args }: CliContext): Promise<void>
         await unlink(fullPath)
       }
     }
-    // Remove MCP config so it gets regenerated with new stack
+    // Remove MCP configs so they get regenerated with new stack
     const mcpCandidates = [
       '.vscode/mcp.json',
       '.cursor/mcp.json',
       '.claude/mcp.json',
+      'opencode.json',
     ]
     for (const mcpPath of mcpCandidates) {
       const fullPath = resolve(projectRoot, mcpPath)
@@ -139,69 +191,90 @@ export default async function init({ pkgRoot, args }: CliContext): Promise<void>
     }
   }
 
-  // ── Run adapter ─────────────────────────────────────────────────
-  const adapter = await ADAPTERS[ide]()
-  const results = await adapter.install(pkgRoot, projectRoot, stack)
+  // ── Run adapters for each selected IDE ──────────────────────────
+  let totalCreated = 0
+  let totalSkipped = 0
+  const allManagedPaths = { framework: [] as string[], customizable: [] as string[] }
+
+  for (const ide of ides) {
+    const adapter = await ADAPTERS[ide]()
+    const results = await adapter.install(pkgRoot, projectRoot, stack, combinedRepoInfo)
+    totalCreated += results.created.length
+    totalSkipped += results.skipped.length
+
+    const managed = adapter.getManagedPaths()
+    allManagedPaths.framework.push(...managed.framework)
+    allManagedPaths.customizable.push(...managed.customizable)
+  }
 
   // ── Write manifest ──────────────────────────────────────────────
-  const manifest = createManifest(pkg.version, ide)
-  manifest.managedPaths = adapter.getManagedPaths()
+  const manifest = createManifest(pkg.version, ides[0], ides)
+  manifest.managedPaths = allManagedPaths
   manifest.stack = stack
+  manifest.repoInfo = combinedRepoInfo
   await writeManifest(projectRoot, manifest)
 
   // ── Update .gitignore ───────────────────────────────────────────
-  const managedPaths = adapter.getManagedPaths()
-  const gitignoreResult = await updateGitignore(projectRoot, managedPaths)
+  const gitignoreResult = await updateGitignore(projectRoot, allManagedPaths)
 
   // ── Summary ─────────────────────────────────────────────────────
-  const created = results.created.length
-  const skipped = results.skipped.length
-
-  console.log(`  ✓ Created ${created} files`)
+  console.log(`  ${c.green('✓')} Created ${c.bold(String(totalCreated))} files`)
   if (gitignoreResult === 'created') {
-    console.log('  ✓ Created .gitignore with OpenCastle entries')
+    console.log(`  ${c.green('✓')} Created .gitignore with OpenCastle entries`)
   } else if (gitignoreResult === 'updated') {
-    console.log('  ✓ Updated .gitignore with OpenCastle entries')
+    console.log(`  ${c.green('✓')} Updated .gitignore with OpenCastle entries`)
   }
-  if (skipped > 0) {
-    console.log(`  → Skipped ${skipped} existing files`)
+  if (totalSkipped > 0) {
+    console.log(`  ${c.dim('→')} Skipped ${totalSkipped} existing files`)
   }
 
   // ── Env var notice ──────────────────────────────────────────────
-  const envVars = getRequiredMcpEnvVars(stack)
+  const envVars = getRequiredMcpEnvVars(stack, combinedRepoInfo)
   if (envVars.length > 0) {
-    console.log(`\n  ⚠  Required environment variables for MCP servers:\n`)
+    console.log(`\n  ${c.yellow('⚠')}  Required environment variables for MCP servers:\n`)
     for (const { envVar, hint } of envVars) {
-      console.log(`     ${envVar}`)
-      console.log(`     └ ${hint}\n`)
+      console.log(`     ${c.bold(envVar)}`)
+      console.log(`     ${c.dim('└')} ${c.dim(hint)}\n`)
     }
   }
 
   // ── OAuth setup guides ────────────────────────────────────────
-  if (stack.notifications === 'slack') {
-    console.log(`  📖 Slack MCP requires a Slack App with a bot token.`)
-    console.log(`     Setup guide: https://www.opencastle.dev/guides/slack-mcp-setup\n`)
+  if (teamTools.includes('slack')) {
+    console.log(`  ${c.cyan('📖')} Slack MCP requires a Slack App with a bot token.`)
+    console.log(`     Setup guide: ${c.cyan('https://www.opencastle.dev/guides/plugins#slack')}\n`)
   }
 
-  console.log(`\n  Next steps:`)
-  if (ide === 'vscode') {
-    console.log(
-      '  0. Reload VS Code window (Cmd+Shift+P → "Reload Window") to pick up agents'
-    )
-  } else if (ide === 'cursor') {
-    console.log(
-      '  0. Reload Cursor window to pick up the new rule files'
-    )
+  console.log(`\n  ${c.bold('Next steps:')}`)
+
+  let step = 0
+  // Reload window messages for relevant IDEs
+  const needsReload = ides.filter((id) => ['vscode', 'cursor'].includes(id))
+  if (needsReload.length > 0) {
+    step++
+    if (needsReload.includes('vscode')) {
+      console.log(
+        `  ${step}. ${c.yellow('Reload VS Code window')} (Cmd+Shift+P → "Developer: Reload Window")`
+      )
+    }
+    if (needsReload.includes('cursor')) {
+      console.log(
+        `  ${step}. ${c.yellow('Reload Cursor window')} to pick up the new rule files`
+      )
+    }
   }
+
   if (envVars.length > 0) {
+    step++
     console.log(
-      `  1. Set the environment variable${envVars.length > 1 ? 's' : ''} listed above`
+      `  ${step}. Set the environment variable${envVars.length > 1 ? 's' : ''} listed above`
     )
   }
+  step++
   console.log(
-    `  ${envVars.length > 0 ? '2' : '1'}. Run the "Bootstrap Customizations" prompt to configure for your project`
+    `  ${step}. Run the ${c.cyan('"Bootstrap Customizations"')} prompt to configure for your project`
   )
-  console.log(`  ${envVars.length > 0 ? '3' : '2'}. Commit the customizations/ folder to your repository`)
+  step++
+  console.log(`  ${step}. Commit the customizations/ folder to your repository`)
   console.log()
 
   closePrompts()

package/src/cli/manifest.ts

@@ -35,10 +35,11 @@ export async function writeManifest(
 /**
  * Create a fresh manifest object.
  */
-export function createManifest(version: string, ide: string): Manifest {
+export function createManifest(version: string, ide: string, ides?: string[]): Manifest {
   return {
     version,
     ide,
+    ides: ides ?? [ide],
     installedAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
   };

package/src/cli/mcp.ts

@@ -1,91 +1,171 @@
 import { resolve, dirname } from 'node:path';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { getOrchestratorRoot } from './copy.js';
 import { getIncludedMcpServers } from './stack-config.js';
-import type { ScaffoldResult, StackConfig } from './types.js';
+import { PLUGINS } from '../orchestrator/plugins/index.js';
+import type { McpInput } from '../orchestrator/plugins/types.js';
+import type { ScaffoldResult, StackConfig, RepoInfo, IdeChoice } from './types.js';
+
+// ── IDE-specific MCP format transformation ────────────────────
+
+interface VsCodeServer {
+  type: 'stdio' | 'http';
+  command?: string;
+  args?: string[];
+  url?: string;
+  env?: Record<string, string>;
+  envFile?: string;
+}
+
+/**
+ * Transform a VS Code–format MCP config into the format
+ * expected by the given IDE.
+ */
+function transformMcpForIde(
+  ide: IdeChoice,
+  servers: Record<string, VsCodeServer>,
+  inputs?: McpInput[]
+): Record<string, unknown> {
+  switch (ide) {
+    case 'cursor':
+    case 'claude-code': {
+      // mcpServers format — no 'type' field
+      const mcpServers: Record<string, unknown> = {};
+      for (const [name, server] of Object.entries(servers)) {
+        if (server.type === 'stdio') {
+          mcpServers[name] = {
+            command: server.command,
+            args: server.args,
+            ...(server.env && { env: server.env }),
+          };
+        } else if (server.type === 'http') {
+          // Strip VS Code ${input:...} placeholders for non-VS Code IDEs
+          let url = server.url ?? '';
+          url = url.replace(/\$\{input:\w+\}/g, 'REPLACE_ME');
+          mcpServers[name] = { url };
+        }
+      }
+      return { mcpServers };
+    }
+
+    case 'opencode': {
+      // OpenCode format — type: "local"/"remote", command as array
+      const mcp: Record<string, unknown> = {};
+      for (const [name, server] of Object.entries(servers)) {
+        if (server.type === 'stdio') {
+          mcp[name] = {
+            type: 'local',
+            command: [server.command, ...(server.args ?? [])],
+            ...(server.env && { environment: server.env }),
+          };
+        } else if (server.type === 'http') {
+          let url = server.url ?? '';
+          url = url.replace(/\$\{input:\w+\}/g, 'REPLACE_ME');
+          mcp[name] = {
+            type: 'remote',
+            url,
+          };
+        }
+      }
+      return { mcp };
+    }
+
+    default: {
+      // VS Code — return as-is (keep type, inputs, envFile)
+      const result: Record<string, unknown> = { servers };
+      if (inputs && inputs.length > 0) {
+        result.inputs = inputs;
+      }
+      return result;
+    }
+  }
+}
 
 /**
  * Scaffold or merge the MCP server config into the target project.
  *
- * Reads the template from `opencastle/src/orchestrator/mcp.json`,
- * writes it to `<projectRoot>/<destRelPath>` (e.g. `.vscode/mcp.json`).
+ * Builds the server list from plugin configs based on the user's
+ * stack selection. Writes to `<projectRoot>/<destRelPath>`
+ * (e.g. `.vscode/mcp.json`).
  *
- * When a StackConfig is provided, only servers relevant to the chosen
- * CMS/DB stack (plus core servers) are included.
+ * The output format is adapted to match the target IDE's expectations.
  *
  * If the file already exists, missing servers are merged in without
  * overwriting any existing server configs.
  */
 export async function scaffoldMcpConfig(
-  pkgRoot: string,
   projectRoot: string,
   destRelPath: string,
-  stack?: StackConfig
+  stack?: StackConfig,
+  repoInfo?: RepoInfo,
+  ide?: IdeChoice
 ): Promise<ScaffoldResult> {
   const destPath = resolve(projectRoot, destRelPath);
 
-  const srcRoot = getOrchestratorRoot(pkgRoot);
-  const templatePath = resolve(srcRoot, 'mcp.json');
-  const content = await readFile(templatePath, 'utf8');
-
-  const template = JSON.parse(content) as {
-    servers: Record<string, unknown>;
-    inputs?: Array<{ id: string; [key: string]: unknown }>;
-  };
+  // Build server list from plugin configs
+  const servers: Record<string, VsCodeServer> = {};
+  let inputs: McpInput[] = [];
 
-  // Filter servers based on stack config
   if (stack) {
-    const included = getIncludedMcpServers(stack);
-    template.servers = Object.fromEntries(
-      Object.entries(template.servers).filter(([key]) => included.has(key))
-    );
-
-    // Filter inputs to only include those referenced by included servers
-    if (template.inputs) {
-      const serverJson = JSON.stringify(template.servers);
-      template.inputs = template.inputs.filter(
-        (input) => serverJson.includes(`\${input:${input.id}}`)
-      );
-      if (template.inputs.length === 0) {
-        delete template.inputs;
+    const included = getIncludedMcpServers(stack, repoInfo);
+
+    for (const plugin of Object.values(PLUGINS)) {
+      if (plugin.mcpServerKey && included.has(plugin.mcpServerKey)) {
+        servers[plugin.mcpServerKey] = plugin.mcpConfig as VsCodeServer;
+        if (plugin.mcpInputs) {
+          inputs.push(...plugin.mcpInputs);
+        }
       }
     }
   }
 
+  // Transform to IDE-specific format
+  const resolvedIde = ide ?? 'vscode';
+  const output = transformMcpForIde(resolvedIde, servers, inputs.length > 0 ? inputs : undefined);
+
   if (existsSync(destPath)) {
     // Merge: add missing servers without overwriting existing ones
     const existingContent = await readFile(destPath, 'utf8');
-    const existing = JSON.parse(existingContent) as {
-      servers?: Record<string, unknown>;
-      inputs?: Array<{ id: string; [key: string]: unknown }>;
-      [key: string]: unknown;
-    };
-
-    if (!existing.servers) {
-      existing.servers = {};
+    const existing = JSON.parse(existingContent) as Record<string, unknown>;
+
+    // Determine the server container key for this IDE
+    const containerKey = resolvedIde === 'opencode'
+      ? 'mcp'
+      : resolvedIde === 'vscode'
+        ? 'servers'
+        : 'mcpServers';
+
+    if (!existing[containerKey]) {
+      existing[containerKey] = {};
     }
 
+    const existingServers = existing[containerKey] as Record<string, unknown>;
+    const newServers = (output as Record<string, unknown>)[containerKey] as Record<string, unknown> | undefined;
+
     let added = 0;
-    for (const [key, value] of Object.entries(template.servers)) {
-      if (!(key in existing.servers)) {
-        existing.servers[key] = value;
-        added++;
+    if (newServers) {
+      for (const [key, value] of Object.entries(newServers)) {
+        if (!(key in existingServers)) {
+          existingServers[key] = value;
+          added++;
+        }
       }
     }
 
-    // Merge inputs: add missing input definitions
-    if (template.inputs && template.inputs.length > 0) {
-      if (!existing.inputs) {
-        existing.inputs = [];
-      }
-      const existingIds = new Set(existing.inputs.map((i) => i.id));
-      for (const input of template.inputs) {
+    // For VS Code: merge inputs
+    if (resolvedIde === 'vscode' && output.inputs) {
+      const existingInputs = (existing.inputs as McpInput[]) ?? [];
+      const existingIds = new Set(existingInputs.map((i) => i.id));
+      const newInputs = output.inputs as McpInput[];
+      for (const input of newInputs) {
         if (!existingIds.has(input.id)) {
-          existing.inputs.push(input);
+          existingInputs.push(input);
           added++;
         }
       }
+      if (existingInputs.length > 0) {
+        existing.inputs = existingInputs;
+      }
     }
 
     if (added === 0) {
@@ -97,7 +177,7 @@ export async function scaffoldMcpConfig(
   }
 
   await mkdir(dirname(destPath), { recursive: true });
-  await writeFile(destPath, JSON.stringify(template, null, 2) + '\n');
+  await writeFile(destPath, JSON.stringify(output, null, 2) + '\n');
 
   return { path: destPath, action: 'created' };
 }