@swarmclawai/swarmclaw 1.9.4 → 1.9.6

package/src/lib/server/portability/import.ts

@@ -54,22 +54,60 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     idMap,
   }
 
-  // --- Skills first (agents may reference them) ---
+  // --- Projects first (agents, skills, schedules, and goals may reference them) ---
+  if (manifest.projects && manifest.projects.length) {
+    const existingProjects = loadProjects() as Record<string, Project>
+    const existingProjectNames = new Set(Object.values(existingProjects).map((p) => p.name))
+    for (const portable of manifest.projects) {
+      const name = deduplicateName(portable.name, existingProjectNames)
+      const id = genId()
+      idMap[portable.originalId] = id
+      existingProjectNames.add(name)
+      const now = Date.now()
+      const project: Project = {
+        id,
+        name,
+        description: portable.description ?? '',
+        color: portable.color,
+        objective: portable.objective,
+        audience: portable.audience,
+        priorities: portable.priorities,
+        openObjectives: portable.openObjectives,
+        capabilityHints: portable.capabilityHints,
+        credentialRequirements: portable.credentialRequirements,
+        successMetrics: portable.successMetrics,
+        heartbeatPrompt: portable.heartbeatPrompt,
+        heartbeatIntervalSec: portable.heartbeatIntervalSec,
+        createdAt: now,
+        updatedAt: now,
+      }
+      existingProjects[id] = project
+      result.projects.created++
+      result.projects.names.push(name)
+    }
+    saveProjects(existingProjects)
+  }
+
+  // --- Skills (agents may reference them) ---
   const existingSkills = loadSkills()
   const existingSkillNames = new Set(Object.values(existingSkills).map((s) => s.name))
+  const pendingSkillAgentLinks: Array<{ skillId: string; originalAgentIds: string[] }> = []
   for (const portable of manifest.skills) {
     const name = deduplicateName(portable.name, existingSkillNames)
     const id = genId()
     idMap[portable.originalId] = id
     existingSkillNames.add(name)
+    const originalProjectId = portable.originalProjectId ?? (portable as { projectId?: string | null }).projectId ?? null
     const skill: Skill = {
       id,
       name,
       filename: `${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.md`,
       content: portable.content,
+      projectId: originalProjectId ? idMap[originalProjectId] || originalProjectId : undefined,
       description: portable.description,
       tags: portable.tags,
       scope: portable.scope || 'global',
+      agentIds: portable.originalAgentIds ? [] : undefined,
       author: portable.author,
       version: portable.version,
       primaryEnv: portable.primaryEnv,
@@ -80,47 +118,51 @@ export function importConfig(manifest: PortableManifest): ImportResult {
       updatedAt: Date.now(),
     }
     saveSkill(id, skill)
+    if (portable.originalAgentIds?.length) {
+      pendingSkillAgentLinks.push({ skillId: id, originalAgentIds: portable.originalAgentIds })
+    }
     result.skills.created++
     result.skills.names.push(name)
   }
 
-  // --- Projects (agents and goals may reference them) ---
-  if (manifest.projects && manifest.projects.length) {
-    const existingProjects = loadProjects() as Record<string, Project>
-    const existingProjectNames = new Set(Object.values(existingProjects).map((p) => p.name))
-    for (const portable of manifest.projects) {
-      const name = deduplicateName(portable.name, existingProjectNames)
+  // --- MCP Servers (agents may reference them) ---
+  if (manifest.mcpServers && manifest.mcpServers.length) {
+    const existingMcp = loadMcpServers() as Record<string, McpServerConfig>
+    const existingMcpNames = new Set(Object.values(existingMcp).map((s) => s.name))
+    for (const portable of manifest.mcpServers) {
+      const name = deduplicateName(portable.name, existingMcpNames)
       const id = genId()
       idMap[portable.originalId] = id
-      existingProjectNames.add(name)
-      const now = Date.now()
-      const project: Project = {
-        id,
-        name,
-        description: portable.description ?? '',
-        color: portable.color,
-        objective: portable.objective,
-        audience: portable.audience,
-        priorities: portable.priorities,
-        openObjectives: portable.openObjectives,
-        capabilityHints: portable.capabilityHints,
-        credentialRequirements: portable.credentialRequirements,
-        successMetrics: portable.successMetrics,
-        heartbeatPrompt: portable.heartbeatPrompt,
-        heartbeatIntervalSec: portable.heartbeatIntervalSec,
-        createdAt: now,
-        updatedAt: now,
+      existingMcpNames.add(name)
+      const env: Record<string, string> = {}
+      for (const key of portable.envKeys || []) env[key] = ''
+      const headers: Record<string, string> = {}
+      for (const key of portable.headerKeys || []) headers[key] = ''
+      existingMcp[id] = {
+        id, name,
+        transport: portable.transport,
+        command: portable.command,
+        args: portable.args,
+        cwd: portable.cwd,
+        url: portable.url,
+        env: Object.keys(env).length ? env : undefined,
+        headers: Object.keys(headers).length ? headers : undefined,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      } as McpServerConfig
+      result.mcpServers.created++
+      result.mcpServers.names.push(name)
+      if ((portable.envKeys?.length || 0) + (portable.headerKeys?.length || 0) > 0) {
+        result.mcpServers.needsCredentials.push(name)
       }
-      existingProjects[id] = project
-      result.projects.created++
-      result.projects.names.push(name)
     }
-    saveProjects(existingProjects)
+    saveMcpServers(existingMcp)
   }
 
   // --- Agents ---
   const existingAgents = loadAgents()
   const existingAgentNames = new Set(Object.values(existingAgents).map((a) => a.name))
+  const pendingAgentGoalLinks: Array<{ agentId: string; originalGoalId: string }> = []
   for (const portable of manifest.agents) {
     const name = deduplicateName(portable.name, existingAgentNames)
     const id = genId()
@@ -128,13 +170,17 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     idMap[portable.originalId] = id
     existingAgentNames.add(name)
     const remappedSkillIds = (portable.skillIds || []).map((sid) => idMap[sid] || sid)
+    const remappedMcpServerIds = (portable.mcpServerIds || []).map((sid) => idMap[sid] || sid)
     const remappedProjectId = portable.projectId && idMap[portable.projectId] ? idMap[portable.projectId] : portable.projectId
+    const originalGoalId = portable.goalId || null
     const agent: Agent = {
       ...(portable as Omit<PortableAgent, 'originalId'>),
       id,
       name,
       skillIds: remappedSkillIds,
+      mcpServerIds: remappedMcpServerIds,
       projectId: remappedProjectId,
+      goalId: originalGoalId && idMap[originalGoalId] ? idMap[originalGoalId] : originalGoalId,
       threadSessionId: null,
       lastUsedAt: undefined,
       totalCost: undefined,
@@ -148,9 +194,23 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     existingAgents[id] = agent
     result.agents.created++
     result.agents.names.push(name)
+    if (originalGoalId) pendingAgentGoalLinks.push({ agentId: id, originalGoalId })
   }
   saveAgents(existingAgents)
 
+  if (pendingSkillAgentLinks.length) {
+    const skills = loadSkills()
+    for (const pending of pendingSkillAgentLinks) {
+      const skill = skills[pending.skillId]
+      if (!skill) continue
+      skill.agentIds = pending.originalAgentIds
+        .map((agentId) => idMap[agentId])
+        .filter((agentId): agentId is string => Boolean(agentId))
+      skill.updatedAt = Date.now()
+      saveSkill(pending.skillId, skill)
+    }
+  }
+
   // --- Schedules (need agent ID mapping) ---
   const existingSchedules = loadSchedules()
   const existingScheduleNames = new Set(Object.values(existingSchedules).map((s) => s.name))
@@ -163,9 +223,21 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     existingScheduleNames.add(name)
     const schedule: Schedule = {
       id, name, agentId: newAgentId,
+      projectId: portable.projectId ? idMap[portable.projectId] || portable.projectId : undefined,
       taskPrompt: portable.taskPrompt,
       taskMode: portable.taskMode,
       message: portable.message,
+      protocolTemplateId: portable.protocolTemplateId,
+      protocolParticipantAgentIds: (portable.protocolParticipantAgentIds || [])
+        .map((agentId) => idMap[agentId])
+        .filter((agentId): agentId is string => Boolean(agentId)),
+      protocolFacilitatorAgentId: portable.protocolFacilitatorAgentId
+        ? idMap[portable.protocolFacilitatorAgentId] || null
+        : null,
+      protocolObserverAgentIds: (portable.protocolObserverAgentIds || [])
+        .map((agentId) => idMap[agentId])
+        .filter((agentId): agentId is string => Boolean(agentId)),
+      protocolConfig: portable.protocolConfig,
       description: portable.description,
       scheduleType: portable.scheduleType,
       frequency: portable.frequency,
@@ -184,41 +256,48 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     result.schedules.names.push(name)
   }
 
-  // --- MCP Servers ---
-  if (manifest.mcpServers && manifest.mcpServers.length) {
-    const existingMcp = loadMcpServers() as Record<string, McpServerConfig>
-    const existingMcpNames = new Set(Object.values(existingMcp).map((s) => s.name))
-    for (const portable of manifest.mcpServers) {
-      const name = deduplicateName(portable.name, existingMcpNames)
+  // --- Chatrooms ---
+  if (manifest.chatrooms && manifest.chatrooms.length) {
+    const existingChatrooms = loadChatrooms()
+    const existingChatroomNames = new Set(Object.values(existingChatrooms).map((c) => c.name))
+    for (const portable of manifest.chatrooms) {
+      const name = deduplicateName(portable.name, existingChatroomNames)
       const id = genId()
       idMap[portable.originalId] = id
-      existingMcpNames.add(name)
-      const env: Record<string, string> = {}
-      for (const key of portable.envKeys || []) env[key] = ''
-      const headers: Record<string, string> = {}
-      for (const key of portable.headerKeys || []) headers[key] = ''
-      existingMcp[id] = {
+      existingChatroomNames.add(name)
+      const now = Date.now()
+      const remappedAgentIds = portable.originalAgentIds
+        .map((aid) => idMap[aid])
+        .filter((aid): aid is string => Boolean(aid))
+      const remappedRules = (portable.routingRules || []).map((r, idx) => ({
+        id: `route-${idx + 1}`,
+        type: r.type,
+        pattern: r.pattern,
+        keywords: r.keywords,
+        agentId: idMap[r.originalAgentId] || r.originalAgentId,
+        priority: r.priority,
+      }))
+      const chatroom: Chatroom = {
         id, name,
-        transport: portable.transport,
-        command: portable.command,
-        args: portable.args,
-        cwd: portable.cwd,
-        url: portable.url,
-        env: Object.keys(env).length ? env : undefined,
-        headers: Object.keys(headers).length ? headers : undefined,
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-      } as McpServerConfig
-      result.mcpServers.created++
-      result.mcpServers.names.push(name)
-      if ((portable.envKeys?.length || 0) + (portable.headerKeys?.length || 0) > 0) {
-        result.mcpServers.needsCredentials.push(name)
+        description: portable.description,
+        agentIds: remappedAgentIds,
+        messages: [],
+        chatMode: portable.chatMode,
+        autoAddress: portable.autoAddress,
+        routingGuidance: portable.routingGuidance,
+        routingRules: remappedRules,
+        temporary: portable.temporary,
+        topic: portable.topic,
+        createdAt: now,
+        updatedAt: now,
       }
+      upsertChatroom(id, chatroom)
+      result.chatrooms.created++
+      result.chatrooms.names.push(name)
     }
-    saveMcpServers(existingMcp)
   }
 
-  // --- Connectors ---
+  // --- Connectors (after chatrooms so room-bound connectors can remap) ---
   if (manifest.connectors && manifest.connectors.length) {
     const existingConnectors = loadConnectors()
     const existingConnectorNames = new Set(Object.values(existingConnectors).map((c) => c.name))
@@ -256,47 +335,6 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     }
   }
 
-  // --- Chatrooms ---
-  if (manifest.chatrooms && manifest.chatrooms.length) {
-    const existingChatrooms = loadChatrooms()
-    const existingChatroomNames = new Set(Object.values(existingChatrooms).map((c) => c.name))
-    for (const portable of manifest.chatrooms) {
-      const name = deduplicateName(portable.name, existingChatroomNames)
-      const id = genId()
-      idMap[portable.originalId] = id
-      existingChatroomNames.add(name)
-      const now = Date.now()
-      const remappedAgentIds = portable.originalAgentIds
-        .map((aid) => idMap[aid])
-        .filter((aid): aid is string => Boolean(aid))
-      const remappedRules = (portable.routingRules || []).map((r, idx) => ({
-        id: `route-${idx + 1}`,
-        type: r.type,
-        pattern: r.pattern,
-        keywords: r.keywords,
-        agentId: idMap[r.originalAgentId] || r.originalAgentId,
-        priority: r.priority,
-      }))
-      const chatroom: Chatroom = {
-        id, name,
-        description: portable.description,
-        agentIds: remappedAgentIds,
-        messages: [],
-        chatMode: portable.chatMode,
-        autoAddress: portable.autoAddress,
-        routingGuidance: portable.routingGuidance,
-        routingRules: remappedRules,
-        temporary: portable.temporary,
-        topic: portable.topic,
-        createdAt: now,
-        updatedAt: now,
-      }
-      upsertChatroom(id, chatroom)
-      result.chatrooms.created++
-      result.chatrooms.names.push(name)
-    }
-  }
-
   // --- Goals (after projects + agents so refs can be remapped) ---
   if (manifest.goals && manifest.goals.length) {
     // Two-pass to handle parent goal refs.
@@ -336,6 +374,18 @@ export function importConfig(manifest: PortableManifest): ImportResult {
     }
   }
 
+  if (pendingAgentGoalLinks.length) {
+    const agents = loadAgents()
+    for (const pending of pendingAgentGoalLinks) {
+      const remappedGoalId = idMap[pending.originalGoalId]
+      const agent = agents[pending.agentId]
+      if (!agent || !remappedGoalId) continue
+      agent.goalId = remappedGoalId
+      agent.updatedAt = Date.now()
+    }
+    saveAgents(agents)
+  }
+
   logActivity({
     entityType: 'system',
     entityId: 'portability',

package/src/lib/validation/schemas.ts

@@ -619,6 +619,8 @@ const PortableSkillSchema = z.object({
   originalId: z.string().min(1),
   name: z.string().min(1),
   content: z.string(),
+  originalProjectId: z.string().nullable().optional(),
+  originalAgentIds: z.array(z.string()).optional(),
 }).passthrough()
 
 const PortableScheduleSchema = z.object({
@@ -627,13 +629,64 @@ const PortableScheduleSchema = z.object({
   name: z.string().min(1),
 }).passthrough()
 
+const PortableConnectorSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  platform: z.string().min(1),
+}).passthrough()
+
+const PortableChatroomSchema = z.object({
+  originalId: z.string().min(1),
+  originalAgentIds: z.array(z.string()),
+  name: z.string().min(1),
+}).passthrough()
+
+const PortableMcpServerSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  transport: z.string().min(1),
+}).passthrough()
+
+const PortableProjectSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+}).passthrough()
+
+const PortableGoalSchema = z.object({
+  originalId: z.string().min(1),
+  title: z.string().min(1),
+  level: z.string().min(1),
+  objective: z.string().min(1),
+  status: z.string().min(1),
+}).passthrough()
+
+const PortableExtensionRefSchema = z.object({
+  name: z.string().min(1),
+}).passthrough()
+
+const PortableManifestScopeSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('all') }).passthrough(),
+  z.object({
+    kind: z.literal('project'),
+    originalProjectId: z.string().min(1),
+    projectName: z.string().min(1),
+  }).passthrough(),
+])
+
 export const PortableManifestSchema = z.object({
   formatVersion: z.number().int().nonnegative(),
   exportedAt: z.string().optional(),
+  scope: PortableManifestScopeSchema.optional(),
   agents: z.array(PortableAgentSchema),
   skills: z.array(PortableSkillSchema),
   schedules: z.array(PortableScheduleSchema),
-})
+  connectors: z.array(PortableConnectorSchema).optional(),
+  chatrooms: z.array(PortableChatroomSchema).optional(),
+  mcpServers: z.array(PortableMcpServerSchema).optional(),
+  projects: z.array(PortableProjectSchema).optional(),
+  goals: z.array(PortableGoalSchema).optional(),
+  extensions: z.array(PortableExtensionRefSchema).optional(),
+}).passthrough()
 
 /** Format ZodError into a 400-friendly payload */
 export function formatZodError(err: z.ZodError) {