fix: Cross-platform file open handler for .unit files (macOS double-click support)

gradle.properties

@@ -61,3 +61,6 @@ kotlin.js.yarn=false
 kotlin.incremental.js=false
 kotlin.incremental.js.ir=false
 
+# Ignore disabled Kotlin/Native targets
+kotlin.native.ignoreDisabledTargets=true
+

mpp-core/build.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 
     // Temporarily disabled: npm publish plugin doesn't support wasmJs targets
     // TODO: Re-enable once plugin supports wasmJs or split into separate modules
-     id("dev.petuska.npm.publish") version "3.5.3"
+    // id("dev.petuska.npm.publish") version "3.5.3"
 }
 
 repositories {
@@ -264,13 +264,6 @@ kotlin {
 
                 implementation(npm("wasm-git", "0.0.13"))
 
-                // Force kotlin-stdlib to 2.2.0 to match compiler version
-                implementation("org.jetbrains.kotlin:kotlin-stdlib") {
-                    version {
-                        strictly("2.2.0")
-                    }
-                }
-
                 // WASM specific dependencies if needed
             }
         }
@@ -283,6 +276,8 @@ kotlin {
     }
 }
 
+// Temporarily disabled: npm publish plugin doesn't support wasmJs targets
+/*
 npmPublish {
     organization.set("xiuper")
 
@@ -309,6 +304,7 @@ npmPublish {
         }
     }
 }
+*/
 
 // Disable wasmJs browser tests due to webpack compatibility issues
 // See: https://github.com/webpack/webpack/issues/XXX
@@ -331,3 +327,13 @@ tasks.register<JavaExec>("runNanoDslScenarioHarness") {
     classpath = kotlin.jvm().compilations.getByName("main").runtimeDependencyFiles +
         files(kotlin.jvm().compilations.getByName("main").output.classesDirs)
 }
+
+// Task to generate a test .unit file
+tasks.register<JavaExec>("generateTestUnit") {
+    group = "verification"
+    description = "Generate a test .unit file for verification"
+
+    val jvmCompilation = kotlin.jvm().compilations.getByName("main")
+    classpath(jvmCompilation.output, configurations["jvmRuntimeClasspath"])
+    mainClass.set("cc.unitmesh.agent.artifact.GenerateTestUnitKt")
+}

mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/artifact/ArtifactBundlePacker.android.kt

@@ -0,0 +1,113 @@
+package cc.unitmesh.agent.artifact
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.*
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+/**
+ * Android implementation of ArtifactBundlePacker
+ * Uses java.util.zip for ZIP operations (same as JVM)
+ */
+actual class ArtifactBundlePacker {
+
+    actual suspend fun pack(bundle: ArtifactBundle, outputPath: String): PackResult =
+        withContext(Dispatchers.IO) {
+            try {
+                val outputFile = File(outputPath)
+                outputFile.parentFile?.mkdirs()
+
+                ZipOutputStream(FileOutputStream(outputFile)).use { zipOut ->
+                    // Add ARTIFACT.md
+                    val artifactMd = bundle.generateArtifactMd()
+                    addZipEntry(zipOut, ArtifactBundle.ARTIFACT_MD, artifactMd)
+
+                    // Add package.json
+                    val packageJson = bundle.generatePackageJson()
+                    addZipEntry(zipOut, ArtifactBundle.PACKAGE_JSON, packageJson)
+
+                    // Add main content
+                    val mainFileName = bundle.getMainFileName()
+                    addZipEntry(zipOut, mainFileName, bundle.mainContent)
+
+                    // Add additional files
+                    bundle.files.forEach { (fileName, content) ->
+                        addZipEntry(zipOut, fileName, content)
+                    }
+
+                    // Add context.json
+                    val contextJson = ArtifactBundleUtils.serializeBundle(bundle)
+                    addZipEntry(zipOut, ArtifactBundle.CONTEXT_JSON, contextJson)
+                }
+
+                PackResult.Success(outputPath)
+            } catch (e: Exception) {
+                PackResult.Error("Failed to pack bundle: ${e.message}", e)
+            }
+        }
+
+    actual suspend fun unpack(inputPath: String): UnpackResult =
+        withContext(Dispatchers.IO) {
+            try {
+                val files = mutableMapOf<String, String>()
+
+                ZipInputStream(FileInputStream(inputPath)).use { zipIn ->
+                    var entry: ZipEntry? = zipIn.nextEntry
+                    while (entry != null) {
+                        if (!entry.isDirectory) {
+                            val content = zipIn.readBytes().toString(Charsets.UTF_8)
+                            files[entry.name] = content
+                        }
+                        zipIn.closeEntry()
+                        entry = zipIn.nextEntry
+                    }
+                }
+
+                val bundle = ArtifactBundleUtils.reconstructBundle(files)
+                if (bundle != null) {
+                    UnpackResult.Success(bundle)
+                } else {
+                    UnpackResult.Error("Failed to reconstruct bundle from ZIP contents")
+                }
+            } catch (e: Exception) {
+                UnpackResult.Error("Failed to unpack bundle: ${e.message}", e)
+            }
+        }
+
+    actual suspend fun extractToDirectory(inputPath: String, outputDir: String): PackResult =
+        withContext(Dispatchers.IO) {
+            try {
+                val outputDirectory = File(outputDir)
+                outputDirectory.mkdirs()
+
+                ZipInputStream(FileInputStream(inputPath)).use { zipIn ->
+                    var entry: ZipEntry? = zipIn.nextEntry
+                    while (entry != null) {
+                        if (!entry.isDirectory) {
+                            val outputFile = File(outputDirectory, entry.name)
+                            outputFile.parentFile?.mkdirs()
+
+                            FileOutputStream(outputFile).use { fileOut ->
+                                zipIn.copyTo(fileOut)
+                            }
+                        }
+                        zipIn.closeEntry()
+                        entry = zipIn.nextEntry
+                    }
+                }
+
+                PackResult.Success(outputDir)
+            } catch (e: Exception) {
+                PackResult.Error("Failed to extract bundle: ${e.message}", e)
+            }
+        }
+
+    private fun addZipEntry(zipOut: ZipOutputStream, fileName: String, content: String) {
+        val entry = ZipEntry(fileName)
+        zipOut.putNextEntry(entry)
+        zipOut.write(content.toByteArray(Charsets.UTF_8))
+        zipOut.closeEntry()
+    }
+}

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/AgentType.kt

@@ -45,7 +45,13 @@ enum class AgentType {
     /**
      * Web edit mode - browse, select DOM elements, and interact with web pages
      */
-    WEB_EDIT;
+    WEB_EDIT,
+
+    /**
+     * Artifact mode - generate reversible, executable artifacts (HTML/JS, Python scripts)
+     * Similar to Claude's Artifacts system
+     */
+    ARTIFACT;
 
     fun getDisplayName(): String = when (this) {
         LOCAL_CHAT -> "Chat"
@@ -55,6 +61,7 @@ enum class AgentType {
         CHAT_DB -> "ChatDB"
         REMOTE -> "Remote"
         WEB_EDIT -> "WebEdit"
+        ARTIFACT -> "Artifact"
     }
 
     companion object {
@@ -67,6 +74,7 @@ enum class AgentType {
                 "documentreader", "documents" -> KNOWLEDGE
                 "chatdb", "database" -> CHAT_DB
                 "webedit", "web" -> WEB_EDIT
+                "artifact", "unit" -> ARTIFACT
                 else -> LOCAL_CHAT
             }
         }