@clawos-dev/clawd 0.2.98 → 0.2.99-beta.190.29dcdb5

package/dist/cli.cjs

@@ -168,7 +168,19 @@ var init_methods = __esm({
       "extension.list",
       "extension.open",
       "extension.close",
-      "extension.uninstall"
+      "extension.uninstall",
+      // ---- extension sharing v1 (spec 2026-05-28-clawd-extension-sharing-design) ----
+      // owner-side: 公开 / 撤回 / 查 publish 状态（owner-only ADMIN_ANY）
+      "extension.publish",
+      "extension.unpublish",
+      "extension.publish:status",
+      // cross-tunnel: guest 从 owner 拉 published list + bundle（CAPABILITY_SCOPED）
+      "extension.list-published",
+      "extension.fetchBundle",
+      // guest-self: guest 在自己 daemon 上做安装与更新（ADMIN_ANY，guest 是 owner of self daemon）.
+      // 无 subscription 持久化：guest 端身份完全来自文件系统 + reconciled publishedExtensions.
+      "extension.install-from-channel",
+      "extension.update-from-channel"
     ];
   }
 });
@@ -660,8 +672,8 @@ var init_parseUtil = __esm({
     init_errors2();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path53, errorMaps, issueData } = params;
-      const fullPath = [...path53, ...issueData.path || []];
+      const { data, path: path58, errorMaps, issueData } = params;
+      const fullPath = [...path58, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -972,11 +984,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path53, key) {
+      constructor(parent, value, path58, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path53;
+        this._path = path58;
         this._key = key;
       }
       get path() {
@@ -5355,7 +5367,18 @@ var init_received_capability = __esm({
 });
 
 // ../protocol/src/extension.ts
-var EXT_ID_REGEX, ExtensionStateSchema, ExtensionManifestSchema, ExtensionRecordSchema;
+function ownerNamespace(ownerPrincipalId) {
+  let h = 2166136261;
+  for (let i = 0; i < ownerPrincipalId.length; i++) {
+    h ^= ownerPrincipalId.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function namespacedExtId(slug, ownerPrincipalId) {
+  return `${slug}-${ownerNamespace(ownerPrincipalId)}`;
+}
+var EXT_ID_REGEX, ExtensionStateSchema, ExtensionManifestSchema, ExtensionRecordSchema, PublishedSnapshotSchema, ChannelRefSchema, SourceRefSchema, PublishedExtensionRecordSchema, PublishCheckSchema, PublishStatusResultSchema;
 var init_extension = __esm({
   "../protocol/src/extension.ts"() {
     "use strict";
@@ -5409,6 +5432,72 @@ var init_extension = __esm({
         invalidReason: external_exports.string().min(1)
       })
     ]);
+    PublishedSnapshotSchema = external_exports.object({
+      snapshotHash: external_exports.string().min(1),
+      version: external_exports.string().min(1),
+      publishedAt: external_exports.number()
+    });
+    ChannelRefSchema = external_exports.discriminatedUnion("kind", [
+      external_exports.object({
+        kind: external_exports.literal("p2p-tunnel"),
+        ownerPrincipalId: external_exports.string().min(1),
+        extId: external_exports.string().min(1)
+      })
+    ]);
+    SourceRefSchema = external_exports.discriminatedUnion("kind", [
+      external_exports.object({
+        kind: external_exports.literal("p2p-tunnel"),
+        ownerPrincipalId: external_exports.string().min(1),
+        extId: external_exports.string().min(1),
+        snapshotHash: external_exports.string().min(1)
+      })
+    ]);
+    PublishedExtensionRecordSchema = external_exports.object({
+      extId: external_exports.string().min(1),
+      name: external_exports.string().min(1),
+      version: external_exports.string().min(1),
+      contentHash: external_exports.string().min(1),
+      publishedAt: external_exports.number()
+    });
+    PublishCheckSchema = external_exports.discriminatedUnion("kind", [
+      external_exports.object({ kind: external_exports.literal("clean") }),
+      external_exports.object({
+        kind: external_exports.literal("ready-new-version"),
+        fromVersion: external_exports.string().min(1),
+        toVersion: external_exports.string().min(1)
+      }),
+      external_exports.object({
+        kind: external_exports.literal("error-same-hash"),
+        version: external_exports.string().min(1)
+      }),
+      external_exports.object({
+        kind: external_exports.literal("error-version-not-bumped"),
+        localVersion: external_exports.string().min(1),
+        publishedVersion: external_exports.string().min(1)
+      }),
+      external_exports.object({
+        kind: external_exports.literal("error-version-regression"),
+        localVersion: external_exports.string().min(1),
+        publishedVersion: external_exports.string().min(1)
+      })
+    ]);
+    PublishStatusResultSchema = external_exports.object({
+      localManifest: external_exports.object({
+        name: external_exports.string().min(1),
+        version: external_exports.string().min(1),
+        contentHash: external_exports.string().min(1)
+      }),
+      publishState: external_exports.discriminatedUnion("kind", [
+        external_exports.object({ kind: external_exports.literal("unpublished") }),
+        external_exports.object({
+          kind: external_exports.literal("published"),
+          version: external_exports.string().min(1),
+          contentHash: external_exports.string().min(1),
+          publishedAt: external_exports.number()
+        })
+      ]),
+      check: PublishCheckSchema
+    });
   }
 });
 
@@ -5703,8 +5792,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path53 = req.path;
-        _req.url = typeof path53 === "string" ? path53 : req.url ? req.url.path || req.url : void 0;
+        const path58 = req.path;
+        _req.url = typeof path58 === "string" ? path58 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -5869,14 +5958,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path53) {
+    function parsePath(path58) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path53.length; i++) {
-        const char = path53[i];
+      for (let i = 0; i < path58.length; i++) {
+        const char = path58[i];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -6007,10 +6096,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path53 of paths) {
-        const parts = parsePath(path53);
+      for (const path58 of paths) {
+        const parts = parsePath(path58);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path53, remove);
+          redactWildcardPath(obj, parts, censor, path58, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -6095,8 +6184,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path53) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path53];
+            const wrappedCensor = typeof censor === "function" ? (value, path58) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path58];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -6131,8 +6220,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path53 of pathsToClone) {
-        const parts = parsePath(path53);
+      for (const path58 of pathsToClone) {
+        const parts = parsePath(path58);
         let current = pathStructure;
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
@@ -6184,24 +6273,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path53) {
-      if (typeof path53 !== "string") {
+    function validatePath(path58) {
+      if (typeof path58 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path53 === "") {
+      if (path58 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path53.includes("..")) {
-        throw new Error(`Invalid redaction path (${path53})`);
+      if (path58.includes("..")) {
+        throw new Error(`Invalid redaction path (${path58})`);
       }
-      if (path53.includes(",")) {
-        throw new Error(`Invalid redaction path (${path53})`);
+      if (path58.includes(",")) {
+        throw new Error(`Invalid redaction path (${path58})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path53.length; i++) {
-        const char = path53[i];
+      for (let i = 0; i < path58.length; i++) {
+        const char = path58[i];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -6215,20 +6304,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path53})`);
+            throw new Error(`Invalid redaction path (${path58})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path53})`);
+        throw new Error(`Invalid redaction path (${path58})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path53 of paths) {
-        validatePath(path53);
+      for (const path58 of paths) {
+        validatePath(path58);
       }
     }
     function slowRedact(options = {}) {
@@ -6396,8 +6485,8 @@ var require_redaction = __commonJS({
         if (shape[k2] === null) {
           o[k2] = (value) => topCensor(value, [k2]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path53) => {
-            return censor(value, [k2, ...path53]);
+          const wrappedCensor = typeof censor === "function" ? (value, path58) => {
+            return censor(value, [k2, ...path58]);
           } : censor;
           o[k2] = Redact({
             paths: shape[k2],
@@ -6615,10 +6704,10 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs41 = require("fs");
+    var fs46 = require("fs");
     var EventEmitter2 = require("events");
     var inherits = require("util").inherits;
-    var path53 = require("path");
+    var path58 = require("path");
     var sleep = require_atomic_sleep();
     var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -6672,20 +6761,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs41.mkdirSync(path53.dirname(file), { recursive: true });
-          const fd = fs41.openSync(file, flags, mode);
+          if (sonic.mkdir) fs46.mkdirSync(path58.dirname(file), { recursive: true });
+          const fd = fs46.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs41.mkdir(path53.dirname(file), { recursive: true }, (err) => {
+        fs46.mkdir(path58.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs41.open(file, flags, mode, fileOpened);
+          fs46.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs41.open(file, flags, mode, fileOpened);
+        fs46.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -6726,8 +6815,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs41.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs41.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs46.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs46.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -6736,15 +6825,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs41.writeSync(this.fd, this._writingBuf);
+            return fs46.writeSync(this.fd, this._writingBuf);
           }
-          return fs41.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs46.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs41.write(this.fd, this._writingBuf, this.release);
+            return fs46.write(this.fd, this._writingBuf, this.release);
           }
-          return fs41.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs46.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -6801,7 +6890,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs41.fsyncSync(this.fd);
+          fs46.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -6915,7 +7004,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs41.fsync(this.fd, (err) => {
+            fs46.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -7017,7 +7106,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs41.close(fd, (err) => {
+          fs46.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -7066,7 +7155,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs41.writeSync(this.fd, buf) : fs41.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs46.writeSync(this.fd, buf) : fs46.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -7082,7 +7171,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs41.fsyncSync(this.fd);
+        fs46.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -7103,7 +7192,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs41.writeSync(this.fd, buf);
+          const n = fs46.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -7131,13 +7220,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs41.writeSync(this.fd, this._writingBuf) : fs41.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs46.writeSync(this.fd, this._writingBuf) : fs46.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs41.write(this.fd, this._writingBuf, release);
+        fs46.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -7146,7 +7235,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs41.writeSync(this.fd, this._writingBuf);
+          const written = fs46.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -7155,7 +7244,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs41.write(this.fd, this._writingBuf, release);
+        fs46.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -7171,12 +7260,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs41.fsync(sonic.fd, closeWrapped);
+        fs46.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs41.close(sonic.fd, done);
+          fs46.close(sonic.fd, done);
         } else {
           done();
         }
@@ -9540,7 +9629,7 @@ var require_multistream = __commonJS({
 var require_pino = __commonJS({
   "../node_modules/.pnpm/pino@9.14.0/node_modules/pino/pino.js"(exports2, module2) {
     "use strict";
-    var os19 = require("os");
+    var os21 = require("os");
     var stdSerializers = require_pino_std_serializers();
     var caller = require_caller();
     var redaction = require_redaction();
@@ -9587,7 +9676,7 @@ var require_pino = __commonJS({
     } = symbols;
     var { epochTime, nullTime } = time;
     var { pid } = process;
-    var hostname = os19.hostname();
+    var hostname = os21.hostname();
     var defaultErrorSerializer = stdSerializers.err;
     var defaultOptions = {
       level: "info",
@@ -10311,11 +10400,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path53, added, removed, oldPosInc, options) {
-        var last = path53.lastComponent;
+      addToPath: function addToPath(path58, added, removed, oldPosInc, options) {
+        var last = path58.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path53.oldPos + oldPosInc,
+            oldPos: path58.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -10325,7 +10414,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path53.oldPos + oldPosInc,
+            oldPos: path58.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -10771,10 +10860,10 @@ function attachmentToHistoryMessage(o, ts) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec = m2;
-      const path53 = typeof rec.path === "string" ? rec.path : null;
+      const path58 = typeof rec.path === "string" ? rec.path : null;
       const content = typeof rec.content === "string" ? rec.content : null;
-      if (!path53 || content == null) return null;
-      const entry = { path: path53, content };
+      if (!path58 || content == null) return null;
+      const entry = { path: path58, content };
       if (typeof rec.mtimeMs === "number") entry.mtimeMs = rec.mtimeMs;
       return entry;
     }).filter((m2) => m2 !== null);
@@ -11605,10 +11694,10 @@ function parseAttachment(obj) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec = m2;
-      const path53 = typeof rec.path === "string" ? rec.path : null;
+      const path58 = typeof rec.path === "string" ? rec.path : null;
       const content = typeof rec.content === "string" ? rec.content : null;
-      if (!path53 || content == null) return null;
-      const out = { path: path53, content };
+      if (!path58 || content == null) return null;
+      const out = { path: path58, content };
       if (typeof rec.mtimeMs === "number") out.mtimeMs = rec.mtimeMs;
       return out;
     }).filter((m2) => m2 !== null);
@@ -23397,8 +23486,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path53) {
-      var parts = path53.split("/");
+    exports2.resolve = function(path58) {
+      var parts = path58.split("/");
       var result = [];
       for (var index = 0; index < parts.length; index++) {
         var part = parts[index];
@@ -29251,18 +29340,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path53) {
-      if (path53.slice(-1) === "/") {
-        path53 = path53.substring(0, path53.length - 1);
+    var parentFolder = function(path58) {
+      if (path58.slice(-1) === "/") {
+        path58 = path58.substring(0, path58.length - 1);
       }
-      var lastSlash = path53.lastIndexOf("/");
-      return lastSlash > 0 ? path53.substring(0, lastSlash) : "";
+      var lastSlash = path58.lastIndexOf("/");
+      return lastSlash > 0 ? path58.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path53) {
-      if (path53.slice(-1) !== "/") {
-        path53 += "/";
+    var forceTrailingSlash = function(path58) {
+      if (path58.slice(-1) !== "/") {
+        path58 += "/";
       }
-      return path53;
+      return path58;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults.createFolders;
@@ -30228,9 +30317,9 @@ var require_load = __commonJS({
 var require_lib3 = __commonJS({
   "../node_modules/.pnpm/jszip@3.10.1/node_modules/jszip/lib/index.js"(exports2, module2) {
     "use strict";
-    function JSZip2() {
-      if (!(this instanceof JSZip2)) {
-        return new JSZip2();
+    function JSZip5() {
+      if (!(this instanceof JSZip5)) {
+        return new JSZip5();
       }
       if (arguments.length) {
         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
@@ -30239,7 +30328,7 @@ var require_lib3 = __commonJS({
       this.comment = null;
       this.root = "";
       this.clone = function() {
-        var newObj = new JSZip2();
+        var newObj = new JSZip5();
         for (var i in this) {
           if (typeof this[i] !== "function") {
             newObj[i] = this[i];
@@ -30248,23 +30337,23 @@ var require_lib3 = __commonJS({
         return newObj;
       };
     }
-    JSZip2.prototype = require_object();
-    JSZip2.prototype.loadAsync = require_load();
-    JSZip2.support = require_support();
-    JSZip2.defaults = require_defaults();
-    JSZip2.version = "3.10.1";
-    JSZip2.loadAsync = function(content, options) {
-      return new JSZip2().loadAsync(content, options);
+    JSZip5.prototype = require_object();
+    JSZip5.prototype.loadAsync = require_load();
+    JSZip5.support = require_support();
+    JSZip5.defaults = require_defaults();
+    JSZip5.version = "3.10.1";
+    JSZip5.loadAsync = function(content, options) {
+      return new JSZip5().loadAsync(content, options);
     };
-    JSZip2.external = require_external();
-    module2.exports = JSZip2;
+    JSZip5.external = require_external();
+    module2.exports = JSZip5;
   }
 });
 
 // src/run-case/recorder.ts
 function startRunCaseRecorder(opts) {
   const now = opts.now ?? Date.now;
-  const dir = import_node_path39.default.dirname(opts.recordPath);
+  const dir = import_node_path44.default.dirname(opts.recordPath);
   let stream = null;
   let closing = false;
   let closedSettled = false;
@@ -30304,12 +30393,12 @@ function startRunCaseRecorder(opts) {
   };
   return { tap, close, closed };
 }
-var import_node_fs30, import_node_path39;
+var import_node_fs30, import_node_path44;
 var init_recorder = __esm({
   "src/run-case/recorder.ts"() {
     "use strict";
     import_node_fs30 = __toESM(require("fs"), 1);
-    import_node_path39 = __toESM(require("path"), 1);
+    import_node_path44 = __toESM(require("path"), 1);
   }
 });
 
@@ -30352,7 +30441,7 @@ var init_wire = __esm({
 // src/run-case/controller.ts
 async function runController(opts) {
   const now = opts.now ?? Date.now;
-  const cwd = opts.cwd ?? (0, import_node_fs31.mkdtempSync)(import_node_path40.default.join(import_node_os17.default.tmpdir(), "clawd-runcase-"));
+  const cwd = opts.cwd ?? (0, import_node_fs31.mkdtempSync)(import_node_path45.default.join(import_node_os19.default.tmpdir(), "clawd-runcase-"));
   const ownsCwd = opts.cwd === void 0;
   const recorder = startRunCaseRecorder({ recordPath: opts.record, now });
   const spawnCtx = { cwd };
@@ -30519,13 +30608,13 @@ async function runController(opts) {
   }
   return exitCode ?? 0;
 }
-var import_node_fs31, import_node_os17, import_node_path40;
+var import_node_fs31, import_node_os19, import_node_path45;
 var init_controller = __esm({
   "src/run-case/controller.ts"() {
     "use strict";
     import_node_fs31 = require("fs");
-    import_node_os17 = __toESM(require("os"), 1);
-    import_node_path40 = __toESM(require("path"), 1);
+    import_node_os19 = __toESM(require("os"), 1);
+    import_node_path45 = __toESM(require("path"), 1);
     init_claude();
     init_stdout_splitter();
     init_permission_stdio();
@@ -30757,7 +30846,7 @@ Env (advanced):
 `;
 
 // src/index.ts
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_node_fs29 = __toESM(require("fs"), 1);
 
 // src/logger.ts
@@ -35581,7 +35670,7 @@ function scanAgentsDir(dir, source, seen, out) {
   }
 }
 function scanPluginAgentsTree(root, pluginName, seen, out) {
-  function walk(dir, namespaces) {
+  function walk2(dir, namespaces) {
     let entries;
     try {
       entries = import_node_fs12.default.readdirSync(dir, { withFileTypes: true });
@@ -35591,7 +35680,7 @@ function scanPluginAgentsTree(root, pluginName, seen, out) {
     for (const ent of entries) {
       const childPath = import_node_path13.default.join(dir, ent.name);
       if (ent.isDirectory() || ent.isSymbolicLink() && isDirLikeSync2(childPath)) {
-        walk(childPath, [...namespaces, ent.name]);
+        walk2(childPath, [...namespaces, ent.name]);
         continue;
       }
       if (!ent.name.endsWith(".md")) continue;
@@ -35611,7 +35700,7 @@ function scanPluginAgentsTree(root, pluginName, seen, out) {
       });
     }
   }
-  walk(root, []);
+  walk2(root, []);
 }
 function readInstalledPlugins2(home) {
   const pluginsDir = import_node_path13.default.join(home, ".claude", "plugins");
@@ -36350,7 +36439,8 @@ var LocalWsServer = class {
       if (verdict !== "pass") {
         if (!wasAuthed && authGate.isAuthed(client.id)) {
           try {
-            const full = this.opts.readyFrameBuilder({ remoteAddress });
+            const principalKind = this.clients.get(client.id)?.ctx?.principal.kind;
+            const full = this.opts.readyFrameBuilder({ remoteAddress, principalKind });
             this.safeSend(this.clients.get(client.id).ws, { type: "ready", ...full });
           } catch (err) {
             this.logger?.warn("post-auth ready frame build failed", { err: err.message });
@@ -40357,7 +40447,430 @@ function buildAttachmentHandlers(deps) {
 }
 
 // src/handlers/extension.ts
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path38 = __toESM(require("path"), 1);
 init_protocol();
+
+// src/extension/bundle-zip.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
+var import_node_crypto11 = __toESM(require("crypto"), 1);
+var import_jszip2 = __toESM(require_lib3(), 1);
+async function bundleExtensionDir(dir) {
+  const entries = await listFilesSorted(dir);
+  const zip = new import_jszip2.default();
+  for (const rel of entries) {
+    const abs = import_node_path34.default.join(dir, rel);
+    const content = await import_promises4.default.readFile(abs);
+    zip.file(rel, content, { date: FIXED_DATE });
+  }
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  const sha256 = import_node_crypto11.default.createHash("sha256").update(buffer).digest("hex");
+  return { buffer, sha256 };
+}
+var FIXED_DATE = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
+var IGNORE_BASENAMES = /* @__PURE__ */ new Set([".DS_Store"]);
+async function listFilesSorted(rootDir) {
+  const out = [];
+  await walk(rootDir, "", out);
+  out.sort();
+  return out;
+}
+async function walk(absRoot, relPrefix, out) {
+  const dirAbs = import_node_path34.default.join(absRoot, relPrefix);
+  const entries = await import_promises4.default.readdir(dirAbs, { withFileTypes: true });
+  for (const e of entries) {
+    if (IGNORE_BASENAMES.has(e.name)) continue;
+    const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      await walk(absRoot, rel, out);
+    } else if (e.isFile()) {
+      out.push(rel);
+    }
+  }
+}
+
+// src/extension/publish-check.ts
+function computePublishCheck(args) {
+  const { localHash, localVersion, head } = args;
+  if (head === null) {
+    return {
+      kind: "ready-new-version",
+      fromVersion: "0.0.0",
+      toVersion: localVersion
+    };
+  }
+  const hashMatch = localHash === head.snapshotHash;
+  if (hashMatch) {
+    if (localVersion === head.version) {
+      return { kind: "clean" };
+    }
+    return { kind: "error-same-hash", version: head.version };
+  }
+  const cmp = compareSemver(localVersion, head.version);
+  if (cmp > 0) {
+    return {
+      kind: "ready-new-version",
+      fromVersion: head.version,
+      toVersion: localVersion
+    };
+  }
+  if (cmp === 0) {
+    return {
+      kind: "error-version-not-bumped",
+      localVersion,
+      publishedVersion: head.version
+    };
+  }
+  return {
+    kind: "error-version-regression",
+    localVersion,
+    publishedVersion: head.version
+  };
+}
+function compareSemver(a, b2) {
+  const pa = parseSimpleSemver(a);
+  const pb = parseSimpleSemver(b2);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] < pb[i]) return -1;
+    if (pa[i] > pb[i]) return 1;
+  }
+  return 0;
+}
+function parseSimpleSemver(v2) {
+  const parts = v2.split(".");
+  if (parts.length !== 3) {
+    throw new Error(`unsupported version "${v2}" \u2014 only MAJOR.MINOR.PATCH allowed`);
+  }
+  const nums = parts.map((p2) => {
+    if (!/^\d+$/.test(p2)) {
+      throw new Error(`unsupported version "${v2}" \u2014 only numeric segments allowed`);
+    }
+    return parseInt(p2, 10);
+  });
+  return nums;
+}
+
+// src/extension/install-flow.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
+var import_node_os17 = __toESM(require("os"), 1);
+var import_node_crypto12 = __toESM(require("crypto"), 1);
+var import_jszip3 = __toESM(require_lib3(), 1);
+
+// src/extension/paths.ts
+var import_node_os16 = __toESM(require("os"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
+function clawdHomeRoot(override) {
+  return override ?? process.env.CLAWD_HOME ?? import_node_path35.default.join(import_node_os16.default.homedir(), ".clawd");
+}
+function extensionsRoot(override) {
+  return import_node_path35.default.join(clawdHomeRoot(override), "extensions");
+}
+function publishedChannelsFile(override) {
+  return import_node_path35.default.join(clawdHomeRoot(override), "extensions-published.json");
+}
+
+// src/extension/install-flow.ts
+var InstallError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function installFromChannel(args, deps) {
+  const { channelRef, snapshotHash, bundleZip } = args;
+  const computed = import_node_crypto12.default.createHash("sha256").update(bundleZip).digest("hex");
+  if (computed !== snapshotHash) {
+    throw new InstallError(
+      "HASH_MISMATCH",
+      `expected ${snapshotHash.slice(0, 8)}\u2026 but got ${computed.slice(0, 8)}\u2026`
+    );
+  }
+  let zip;
+  try {
+    zip = await import_jszip3.default.loadAsync(bundleZip);
+  } catch (e) {
+    throw new InstallError("ZIP_INVALID", `failed to load zip: ${e.message}`);
+  }
+  for (const name of Object.keys(zip.files)) {
+    if (name.includes("..") || name.startsWith("/") || import_node_path36.default.isAbsolute(name)) {
+      throw new InstallError("ZIP_INVALID", `unsafe zip entry: ${name}`);
+    }
+  }
+  const manifestEntry = zip.file("manifest.json");
+  if (!manifestEntry) {
+    throw new InstallError("MANIFEST_NOT_FOUND", "manifest.json missing from bundle");
+  }
+  let manifestJson;
+  try {
+    manifestJson = JSON.parse(await manifestEntry.async("string"));
+  } catch (e) {
+    throw new InstallError(
+      "INVALID_MANIFEST",
+      `manifest.json parse: ${e.message}`
+    );
+  }
+  const parsed = ExtensionManifestSchema.safeParse(manifestJson);
+  if (!parsed.success) {
+    throw new InstallError(
+      "INVALID_MANIFEST",
+      parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+    );
+  }
+  const ownerSlug = parsed.data.id;
+  if (ownerSlug !== channelRef.extId) {
+    throw new InstallError(
+      "SLUG_MISMATCH",
+      `bundle manifest.id "${ownerSlug}" does not match channelRef.extId "${channelRef.extId}"`
+    );
+  }
+  const localExtId = namespacedExtId(ownerSlug, channelRef.ownerPrincipalId);
+  const destDir = import_node_path36.default.join(deps.extensionsRoot, localExtId);
+  let destExists = false;
+  try {
+    await import_promises5.default.access(destDir);
+    destExists = true;
+  } catch {
+  }
+  if (destExists) {
+    throw new InstallError(
+      "ALREADY_EXISTS",
+      `extension ${localExtId} already installed locally (from owner ${channelRef.ownerPrincipalId})`
+    );
+  }
+  const stage = await import_promises5.default.mkdtemp(
+    import_node_path36.default.join(import_node_os17.default.tmpdir(), `clawd-ext-install-${localExtId}-`)
+  );
+  try {
+    for (const [name, entry] of Object.entries(zip.files)) {
+      const dest = import_node_path36.default.join(stage, name);
+      if (entry.dir) {
+        await import_promises5.default.mkdir(dest, { recursive: true });
+        continue;
+      }
+      await import_promises5.default.mkdir(import_node_path36.default.dirname(dest), { recursive: true });
+      if (name === "manifest.json") {
+        const rewritten = { ...parsed.data, id: localExtId };
+        await import_promises5.default.writeFile(dest, JSON.stringify(rewritten, null, 2));
+      } else {
+        await import_promises5.default.writeFile(dest, await entry.async("nodebuffer"));
+      }
+    }
+    await import_promises5.default.mkdir(deps.extensionsRoot, { recursive: true });
+    await import_promises5.default.rename(stage, destDir);
+  } catch (e) {
+    await import_promises5.default.rm(stage, { recursive: true, force: true }).catch(() => {
+    });
+    throw e;
+  }
+  await deps.runtime.open(localExtId);
+  return { extId: localExtId, installedVersion: parsed.data.version };
+}
+
+// src/extension/update-flow.ts
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
+var import_node_os18 = __toESM(require("os"), 1);
+var import_node_crypto13 = __toESM(require("crypto"), 1);
+var import_jszip4 = __toESM(require_lib3(), 1);
+var UpdateError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+async function updateFromChannel(args, deps) {
+  const { channelRef, snapshotHash, bundleZip } = args;
+  const localExtId = namespacedExtId(
+    channelRef.extId,
+    channelRef.ownerPrincipalId
+  );
+  const liveDir = import_node_path37.default.join(deps.extensionsRoot, localExtId);
+  const prevDir = `${liveDir}.prev`;
+  let existingVersion;
+  try {
+    const raw = await import_promises6.default.readFile(import_node_path37.default.join(liveDir, "manifest.json"), "utf8");
+    const parsed2 = ExtensionManifestSchema.safeParse(JSON.parse(raw));
+    if (!parsed2.success) {
+      throw new UpdateError(
+        "INVALID_MANIFEST",
+        `existing manifest invalid: ${parsed2.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    existingVersion = parsed2.data.version;
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw new UpdateError(
+        "NOT_INSTALLED",
+        `${localExtId} is not installed locally`
+      );
+    }
+    if (e instanceof UpdateError) throw e;
+    throw e;
+  }
+  const computed = import_node_crypto13.default.createHash("sha256").update(bundleZip).digest("hex");
+  if (computed !== snapshotHash) {
+    throw new UpdateError(
+      "HASH_MISMATCH",
+      `expected ${snapshotHash.slice(0, 8)}\u2026 but got ${computed.slice(0, 8)}\u2026`
+    );
+  }
+  let zip;
+  try {
+    zip = await import_jszip4.default.loadAsync(bundleZip);
+  } catch (e) {
+    throw new UpdateError("ZIP_INVALID", `failed to load zip: ${e.message}`);
+  }
+  for (const name of Object.keys(zip.files)) {
+    if (name.includes("..") || name.startsWith("/") || import_node_path37.default.isAbsolute(name)) {
+      throw new UpdateError("ZIP_INVALID", `unsafe zip entry: ${name}`);
+    }
+  }
+  const manifestEntry = zip.file("manifest.json");
+  if (!manifestEntry) {
+    throw new UpdateError("MANIFEST_NOT_FOUND", "manifest.json missing from bundle");
+  }
+  let manifestJson;
+  try {
+    manifestJson = JSON.parse(await manifestEntry.async("string"));
+  } catch (e) {
+    throw new UpdateError(
+      "INVALID_MANIFEST",
+      `manifest.json parse: ${e.message}`
+    );
+  }
+  const parsed = ExtensionManifestSchema.safeParse(manifestJson);
+  if (!parsed.success) {
+    throw new UpdateError(
+      "INVALID_MANIFEST",
+      parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+    );
+  }
+  const ownerSlug = parsed.data.id;
+  if (ownerSlug !== channelRef.extId) {
+    throw new UpdateError(
+      "SLUG_MISMATCH",
+      `bundle manifest.id "${ownerSlug}" does not match channelRef.extId "${channelRef.extId}"`
+    );
+  }
+  await deps.runtime.close(localExtId);
+  await import_promises6.default.rm(prevDir, { recursive: true, force: true });
+  await import_promises6.default.rename(liveDir, prevDir);
+  const stage = await import_promises6.default.mkdtemp(
+    import_node_path37.default.join(import_node_os18.default.tmpdir(), `clawd-ext-update-${localExtId}-`)
+  );
+  try {
+    for (const [name, entry] of Object.entries(zip.files)) {
+      const dest = import_node_path37.default.join(stage, name);
+      if (entry.dir) {
+        await import_promises6.default.mkdir(dest, { recursive: true });
+        continue;
+      }
+      await import_promises6.default.mkdir(import_node_path37.default.dirname(dest), { recursive: true });
+      if (name === "manifest.json") {
+        const rewritten = { ...parsed.data, id: localExtId };
+        await import_promises6.default.writeFile(dest, JSON.stringify(rewritten, null, 2));
+      } else {
+        await import_promises6.default.writeFile(dest, await entry.async("nodebuffer"));
+      }
+    }
+    await import_promises6.default.rename(stage, liveDir);
+  } catch (e) {
+    await import_promises6.default.rm(stage, { recursive: true, force: true }).catch(() => {
+    });
+    await import_promises6.default.rename(prevDir, liveDir).catch(() => {
+    });
+    await deps.runtime.open(localExtId).catch(() => {
+    });
+    return {
+      kind: "rolled-back",
+      extId: localExtId,
+      rolledBackTo: existingVersion,
+      reason: `extract failed: ${e.message}`
+    };
+  }
+  try {
+    await deps.runtime.open(localExtId);
+  } catch (e) {
+    await rollback(deps, localExtId, liveDir, prevDir);
+    return {
+      kind: "rolled-back",
+      extId: localExtId,
+      rolledBackTo: existingVersion,
+      reason: e.message
+    };
+  }
+  await import_promises6.default.rm(prevDir, { recursive: true, force: true });
+  return {
+    kind: "updated",
+    extId: localExtId,
+    installedVersion: parsed.data.version
+  };
+}
+async function rollback(deps, localExtId, liveDir, prevDir) {
+  await import_promises6.default.rm(liveDir, { recursive: true, force: true }).catch(() => {
+  });
+  await import_promises6.default.rename(prevDir, liveDir).catch(() => {
+  });
+  await deps.runtime.open(localExtId).catch(() => {
+  });
+}
+
+// src/handlers/extension.ts
+function pickChannelRef(frame) {
+  const ref = frame.channelRef;
+  const parsed = ChannelRefSchema.safeParse(ref);
+  if (!parsed.success) {
+    throw new ClawdError(
+      ERROR_CODES.INVALID_PARAM,
+      `channelRef invalid: ${parsed.error.issues.map((i) => i.message).join("; ")}`
+    );
+  }
+  return parsed.data;
+}
+function pickStringField(frame, name) {
+  const v2 = frame[name];
+  if (typeof v2 !== "string" || v2.length === 0) {
+    throw new ClawdError(ERROR_CODES.INVALID_PARAM, `${name} required`);
+  }
+  return v2;
+}
+async function readManifest(root, extId) {
+  const file = import_node_path38.default.join(root, extId, "manifest.json");
+  let raw;
+  try {
+    raw = await import_promises7.default.readFile(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw new ClawdError(ERROR_CODES.INVALID_PARAM, `extension ${extId} not installed`);
+    }
+    throw e;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (e) {
+    throw new ClawdError(
+      ERROR_CODES.INVALID_PARAM,
+      `manifest.json invalid: ${e.message}`
+    );
+  }
+  const parsed = ExtensionManifestSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new ClawdError(
+      ERROR_CODES.INVALID_PARAM,
+      `manifest schema mismatch: ${parsed.error.issues.map((i) => i.message).join("; ")}`
+    );
+  }
+  return parsed.data;
+}
 function assertOwner(ctx) {
   if (!ctx || ctx.principal.kind !== "owner") {
     throw new ClawdError(ERROR_CODES.FORBIDDEN, "owner only");
@@ -40412,21 +40925,183 @@ function buildExtensionHandlers(deps) {
     await deps.uninstall({ root: deps.root, extId, runtime: deps.runtime });
     return { response: { ok: true } };
   };
+  async function buildSnapshotMeta(extId) {
+    const manifest = await readManifest(deps.root, extId);
+    const { sha256 } = await bundleExtensionDir(import_node_path38.default.join(deps.root, extId));
+    return { manifest, contentHash: sha256 };
+  }
+  const publish = async (frame, _client, ctx) => {
+    assertOwner(ctx);
+    const extId = pickExtId(frame);
+    const { manifest, contentHash } = await buildSnapshotMeta(extId);
+    const head = deps.publishedChannelStore.get(extId);
+    const check = computePublishCheck({
+      localHash: contentHash,
+      localVersion: manifest.version,
+      head
+    });
+    if (check.kind === "clean" && head) {
+      return { response: { snapshotHash: head.snapshotHash, version: head.version } };
+    }
+    if (check.kind === "error-same-hash" && head) {
+      return { response: { snapshotHash: head.snapshotHash, version: head.version } };
+    }
+    if (check.kind === "error-version-not-bumped") {
+      throw new ClawdError(
+        ERROR_CODES.VALIDATION_ERROR,
+        `VERSION_NOT_BUMPED: manifest.version (${check.localVersion}) needs to be > ${check.publishedVersion}`
+      );
+    }
+    if (check.kind === "error-version-regression") {
+      throw new ClawdError(
+        ERROR_CODES.VALIDATION_ERROR,
+        `VERSION_REGRESSION: manifest.version (${check.localVersion}) is lower than published version (${check.publishedVersion})`
+      );
+    }
+    const snapshot = {
+      snapshotHash: contentHash,
+      version: manifest.version,
+      publishedAt: Date.now()
+    };
+    await deps.publishedChannelStore.set(extId, snapshot);
+    return {
+      response: { snapshotHash: snapshot.snapshotHash, version: snapshot.version }
+    };
+  };
+  const unpublish = async (frame, _client, ctx) => {
+    assertOwner(ctx);
+    const extId = pickExtId(frame);
+    await deps.publishedChannelStore.delete(extId);
+    return { response: {} };
+  };
+  const publishStatus = async (frame, _client, ctx) => {
+    assertOwner(ctx);
+    const extId = pickExtId(frame);
+    const { manifest, contentHash } = await buildSnapshotMeta(extId);
+    const head = deps.publishedChannelStore.get(extId);
+    const check = computePublishCheck({
+      localHash: contentHash,
+      localVersion: manifest.version,
+      head
+    });
+    const result = {
+      localManifest: {
+        name: manifest.name,
+        version: manifest.version,
+        contentHash
+      },
+      publishState: head ? {
+        kind: "published",
+        version: head.version,
+        contentHash: head.snapshotHash,
+        publishedAt: head.publishedAt
+      } : { kind: "unpublished" },
+      check
+    };
+    return { response: result };
+  };
+  const listPublished = async (_frame, _client, ctx) => {
+    if (!ctx || ctx.principal.kind !== "guest") {
+      throw new ClawdError(ERROR_CODES.FORBIDDEN, "guest only");
+    }
+    const heads = deps.publishedChannelStore.list();
+    const out = [];
+    for (const { extId, head } of heads) {
+      try {
+        const manifest = await readManifest(deps.root, extId);
+        out.push({
+          extId,
+          name: manifest.name,
+          version: head.version,
+          contentHash: head.snapshotHash,
+          publishedAt: head.publishedAt
+        });
+      } catch {
+      }
+    }
+    return { response: { extensions: out } };
+  };
+  const fetchBundle = async (frame, _client, ctx) => {
+    if (!ctx || ctx.principal.kind !== "guest") {
+      throw new ClawdError(ERROR_CODES.FORBIDDEN, "guest only");
+    }
+    const extId = pickExtId(frame);
+    const expectedHash = pickStringField(frame, "snapshotHash");
+    const { buffer, sha256 } = await bundleExtensionDir(import_node_path38.default.join(deps.root, extId));
+    if (sha256 !== expectedHash) {
+      throw new ClawdError(
+        ERROR_CODES.VALIDATION_ERROR,
+        `HASH_MISMATCH: bundle hash ${sha256.slice(0, 8)}\u2026 \u2260 requested ${expectedHash.slice(0, 8)}\u2026`
+      );
+    }
+    return { response: { zipBase64: buffer.toString("base64") } };
+  };
+  const installFromChannelHandler = async (frame, _client, ctx) => {
+    assertOwner(ctx);
+    const channelRef = pickChannelRef(frame);
+    const snapshotHash = pickStringField(frame, "snapshotHash");
+    const zipBase64 = pickStringField(frame, "zipBase64");
+    const bundleZip = Buffer.from(zipBase64, "base64");
+    try {
+      const { extId, installedVersion } = await installFromChannel(
+        { channelRef, snapshotHash, bundleZip },
+        {
+          extensionsRoot: deps.root,
+          runtime: deps.runtime
+        }
+      );
+      return { response: { extId, installedVersion } };
+    } catch (e) {
+      if (e instanceof InstallError) {
+        throw new ClawdError(ERROR_CODES.VALIDATION_ERROR, `${e.code}: ${e.message}`);
+      }
+      throw e;
+    }
+  };
+  const updateFromChannelHandler = async (frame, _client, ctx) => {
+    assertOwner(ctx);
+    const channelRef = pickChannelRef(frame);
+    const snapshotHash = pickStringField(frame, "snapshotHash");
+    const zipBase64 = pickStringField(frame, "zipBase64");
+    const bundleZip = Buffer.from(zipBase64, "base64");
+    try {
+      const result = await updateFromChannel(
+        { channelRef, snapshotHash, bundleZip },
+        {
+          extensionsRoot: deps.root,
+          runtime: deps.runtime
+        }
+      );
+      return { response: result };
+    } catch (e) {
+      if (e instanceof UpdateError) {
+        throw new ClawdError(ERROR_CODES.VALIDATION_ERROR, `${e.code}: ${e.message}`);
+      }
+      throw e;
+    }
+  };
   return {
     "extension.list": list,
     "extension.open": open,
     "extension.close": close,
-    "extension.uninstall": uninstall2
+    "extension.uninstall": uninstall2,
+    "extension.publish": publish,
+    "extension.unpublish": unpublish,
+    "extension.publish:status": publishStatus,
+    "extension.list-published": listPublished,
+    "extension.fetchBundle": fetchBundle,
+    "extension.install-from-channel": installFromChannelHandler,
+    "extension.update-from-channel": updateFromChannelHandler
   };
 }
 
 // src/extension/registry.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 async function loadAll(root) {
   let entries;
   try {
-    entries = await import_promises4.default.readdir(root, { withFileTypes: true });
+    entries = await import_promises8.default.readdir(root, { withFileTypes: true });
   } catch (e) {
     if (e.code === "ENOENT") return [];
     throw e;
@@ -40435,16 +41110,16 @@ async function loadAll(root) {
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
     if (ent.name.startsWith(".")) continue;
-    records.push(await loadOne(import_node_path34.default.join(root, ent.name), ent.name));
+    records.push(await loadOne(import_node_path39.default.join(root, ent.name), ent.name));
   }
   records.sort((a, b2) => a.extId < b2.extId ? -1 : a.extId > b2.extId ? 1 : 0);
   return records;
 }
 async function loadOne(dir, dirName) {
-  const manifestPath = import_node_path34.default.join(dir, "manifest.json");
+  const manifestPath = import_node_path39.default.join(dir, "manifest.json");
   let raw;
   try {
-    raw = await import_promises4.default.readFile(manifestPath, "utf8");
+    raw = await import_promises8.default.readFile(manifestPath, "utf8");
   } catch {
     return {
       extId: dirName,
@@ -40485,8 +41160,8 @@ async function loadOne(dir, dirName) {
 }
 
 // src/extension/uninstall.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path35 = __toESM(require("path"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var UninstallError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -40495,22 +41170,14 @@ var UninstallError = class extends Error {
   code;
 };
 async function uninstall(deps) {
-  const dir = import_node_path35.default.join(deps.root, deps.extId);
+  const dir = import_node_path40.default.join(deps.root, deps.extId);
   try {
-    await import_promises5.default.access(dir);
+    await import_promises9.default.access(dir);
   } catch {
     throw new UninstallError("NOT_FOUND", `extension ${deps.extId} not installed`);
   }
   await deps.runtime.close(deps.extId);
-  await import_promises5.default.rm(dir, { recursive: true, force: true });
-}
-
-// src/extension/paths.ts
-var import_node_os16 = __toESM(require("os"), 1);
-var import_node_path36 = __toESM(require("path"), 1);
-function extensionsRoot(override) {
-  const home = override ?? process.env.CLAWD_HOME ?? import_node_path36.default.join(import_node_os16.default.homedir(), ".clawd");
-  return import_node_path36.default.join(home, "extensions");
+  await import_promises9.default.rm(dir, { recursive: true, force: true });
 }
 
 // src/handlers/index.ts
@@ -40554,7 +41221,8 @@ function buildMethodHandlers(deps) {
       loadAll,
       runtime: deps.extensionRuntime,
       uninstall,
-      root: extensionsRoot()
+      root: extensionsRoot(),
+      publishedChannelStore: deps.publishedChannelStore
     })
   };
 }
@@ -40677,7 +41345,18 @@ var METHOD_GRANT_MAP = {
   "extension.list": ADMIN_ANY,
   "extension.open": ADMIN_ANY,
   "extension.close": ADMIN_ANY,
-  "extension.uninstall": ADMIN_ANY
+  "extension.uninstall": ADMIN_ANY,
+  // ---- extension sharing v1（spec 2026-05-28-clawd-extension-sharing-design） ----
+  // owner-side：owner 自己管理 publish 状态
+  "extension.publish": ADMIN_ANY,
+  "extension.unpublish": ADMIN_ANY,
+  "extension.publish:status": ADMIN_ANY,
+  // cross-tunnel：guest 从 owner 拉 published list + bundle
+  "extension.list-published": CAPABILITY_SCOPED,
+  "extension.fetchBundle": CAPABILITY_SCOPED,
+  // guest-self：guest 在自己 daemon 上触发安装与更新（无持久化 subscription 概念）
+  "extension.install-from-channel": ADMIN_ANY,
+  "extension.update-from-channel": ADMIN_ANY
 };
 function computeGrantForFrame(method, frame) {
   const rule = METHOD_GRANT_MAP[method];
@@ -40694,8 +41373,8 @@ function computeGrantForFrame(method, frame) {
 
 // src/extension/runtime.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path37 = __toESM(require("path"), 1);
-var import_promises6 = require("timers/promises");
+var import_node_path41 = __toESM(require("path"), 1);
+var import_promises10 = require("timers/promises");
 
 // src/extension/port-allocator.ts
 var import_node_net = __toESM(require("net"), 1);
@@ -40791,7 +41470,7 @@ var Runtime = class {
       /\$CLAWOS_EXT_PORT/g,
       String(port)
     );
-    const dir = import_node_path37.default.join(this.root, extId);
+    const dir = import_node_path41.default.join(this.root, extId);
     const env = {
       ...process.env,
       CLAWOS_EXT_PORT: String(port),
@@ -40867,7 +41546,7 @@ ${handle.stderrTail}`
         if (res.ok) return;
       } catch {
       }
-      await (0, import_promises6.setTimeout)(this.healthzIntervalMs);
+      await (0, import_promises10.setTimeout)(this.healthzIntervalMs);
     }
     throw new RuntimeError(
       "HEALTHZ_FAILED",
@@ -40892,7 +41571,7 @@ ${handle.stderrTail}`
     };
     killGroup("SIGTERM");
     const exited = new Promise((resolve6) => child.once("exit", () => resolve6()));
-    const timed = (0, import_promises6.setTimeout)(5e3).then(() => "timeout");
+    const timed = (0, import_promises10.setTimeout)(5e3).then(() => "timeout");
     const winner = await Promise.race([exited.then(() => "exited"), timed]);
     if (winner === "timeout" && child.exitCode === null) {
       killGroup("SIGKILL");
@@ -40901,11 +41580,118 @@ ${handle.stderrTail}`
   }
 };
 
+// src/extension/published-channels.ts
+var import_promises11 = __toESM(require("fs/promises"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
+init_zod();
+var PublishedChannelsError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var FileSchema = external_exports.object({
+  version: external_exports.literal(1),
+  channels: external_exports.record(
+    external_exports.string(),
+    external_exports.object({
+      extId: external_exports.string().min(1),
+      head: PublishedSnapshotSchema.nullable()
+    })
+  )
+});
+var PublishedChannelStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  channels = /* @__PURE__ */ new Map();
+  loaded = false;
+  async load() {
+    this.channels.clear();
+    let raw;
+    try {
+      raw = await import_promises11.default.readFile(this.filePath, "utf8");
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        this.loaded = true;
+        return;
+      }
+      throw e;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch (e) {
+      throw new PublishedChannelsError(
+        "CORRUPTED_PUBLISHED_CHANNELS",
+        `failed to parse ${this.filePath}: ${e.message}`
+      );
+    }
+    const parsed = FileSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new PublishedChannelsError(
+        "CORRUPTED_PUBLISHED_CHANNELS",
+        `schema mismatch in ${this.filePath}: ${parsed.error.issues.map((i) => i.message).join("; ")}`
+      );
+    }
+    for (const [extId, entry] of Object.entries(parsed.data.channels)) {
+      this.channels.set(extId, entry.head);
+    }
+    this.loaded = true;
+  }
+  /** Returns the head snapshot, or null when unpublished / unknown extId. */
+  get(extId) {
+    this.assertLoaded();
+    return this.channels.get(extId) ?? null;
+  }
+  /** Returns all extIds with a head (i.e. currently published). */
+  list() {
+    this.assertLoaded();
+    const out = [];
+    for (const [extId, head] of this.channels.entries()) {
+      if (head) out.push({ extId, head });
+    }
+    return out;
+  }
+  async set(extId, head) {
+    this.assertLoaded();
+    this.channels.set(extId, head);
+    await this.save();
+  }
+  async delete(extId) {
+    this.assertLoaded();
+    this.channels.delete(extId);
+    await this.save();
+  }
+  assertLoaded() {
+    if (!this.loaded) {
+      throw new Error("PublishedChannelStore not loaded \u2014 call load() first");
+    }
+  }
+  async save() {
+    const data = {
+      version: 1,
+      channels: Object.fromEntries(
+        Array.from(this.channels.entries()).map(([extId, head]) => [
+          extId,
+          { extId, head }
+        ])
+      )
+    };
+    const tmp = `${this.filePath}.tmp`;
+    await import_promises11.default.mkdir(import_node_path42.default.dirname(this.filePath), { recursive: true });
+    await import_promises11.default.writeFile(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+    await import_promises11.default.rename(tmp, this.filePath);
+  }
+};
+
 // src/index.ts
 async function startDaemon(config) {
   const logger = createLogger({
     level: config.logLevel,
-    file: import_node_path38.default.join(config.dataDir, "clawd.log")
+    file: import_node_path43.default.join(config.dataDir, "clawd.log")
   });
   logger.info("starting clawd", { version, config: { port: config.port, host: config.host, dataDir: config.dataDir } });
   const stateMgr = new StateFileManager({ dataDir: config.dataDir });
@@ -40992,7 +41778,7 @@ async function startDaemon(config) {
   const agents = new AgentsScanner();
   const history = new ClaudeHistoryReader();
   let transport = null;
-  const personaStore = new PersonaStore(import_node_path38.default.join(config.dataDir, "personas"));
+  const personaStore = new PersonaStore(import_node_path43.default.join(config.dataDir, "personas"));
   const defaultsRoot = findDefaultsRoot();
   if (defaultsRoot) {
     seedDefaultPersonas({ store: personaStore, defaultsRoot, logger });
@@ -41009,7 +41795,7 @@ async function startDaemon(config) {
     getAdapter,
     historyReader: history,
     dataDir: config.dataDir,
-    personaRoot: import_node_path38.default.join(config.dataDir, "personas"),
+    personaRoot: import_node_path43.default.join(config.dataDir, "personas"),
     personaStore,
     ownerDisplayName,
     ownerPrincipalId,
@@ -41033,7 +41819,7 @@ async function startDaemon(config) {
     // 文件可能 agent 写完又被自己删（罕见），用 size=0 / fallback mime 兜底。
     attachmentGroup: {
       onFileEdit: (input) => {
-        const absPath = import_node_path38.default.isAbsolute(input.relPath) ? input.relPath : import_node_path38.default.join(input.cwd, input.relPath);
+        const absPath = import_node_path43.default.isAbsolute(input.relPath) ? input.relPath : import_node_path43.default.join(input.cwd, input.relPath);
         let size = 0;
         try {
           size = import_node_fs29.default.statSync(absPath).size;
@@ -41120,6 +41906,8 @@ async function startDaemon(config) {
     return `http://${config.host}:${config.port}`;
   };
   const extensionRuntime = new Runtime({ root: extensionsRoot() });
+  const publishedChannelStore = new PublishedChannelStore(publishedChannelsFile());
+  await publishedChannelStore.load();
   const handlers = buildMethodHandlers({
     manager,
     workspace,
@@ -41159,10 +41947,10 @@ async function startDaemon(config) {
       // 'persona/<pid>/owner'，default 走 'default'。
       getSessionScope: (sid) => manager.findOwnedSessionScope(sid),
       // guest path guard：candidate 必须在 personaRoot 子树下
-      personaRoot: import_node_path38.default.join(config.dataDir, "personas")
+      personaRoot: import_node_path43.default.join(config.dataDir, "personas")
     },
     // workspace/git/history/skills/agents handler 共用的 guest path guard 锚点
-    personaRoot: import_node_path38.default.join(config.dataDir, "personas"),
+    personaRoot: import_node_path43.default.join(config.dataDir, "personas"),
     // capability:list / delete handler 依赖
     capabilityManager,
     // personal-cap:get 返回的 shareBaseUrl 用此 base URL：
@@ -41189,7 +41977,9 @@ async function startDaemon(config) {
     connectRemote,
     // extension runtime (v1: local-mode only). Instance owned by daemon top
     // level so stopAll() runs in the shutdown hook below.
-    extensionRuntime
+    extensionRuntime,
+    // extension sharing v1 — owner-side published-channels store.
+    publishedChannelStore
   });
   const authResolver = new AuthContextResolver({
     ownerToken: resolvedAuthToken
@@ -41374,8 +42164,8 @@ async function startDaemon(config) {
       const lines = [
         `Tunnel:      ${r.url}`,
         ...resolvedAuthToken ? [`Connect:     ${connectUrl}`] : [],
-        `Frpc config: ${import_node_path38.default.join(config.dataDir, "frpc.toml")}`,
-        `Frpc log:    ${import_node_path38.default.join(config.dataDir, "frpc.log")}`
+        `Frpc config: ${import_node_path43.default.join(config.dataDir, "frpc.toml")}`,
+        `Frpc log:    ${import_node_path43.default.join(config.dataDir, "frpc.log")}`
       ];
       const width = Math.max(...lines.map((l) => l.length));
       const bar = "\u2550".repeat(width + 4);
@@ -41388,7 +42178,7 @@ ${bar}
 
 `);
       try {
-        const connectPath = import_node_path38.default.join(config.dataDir, "connect.txt");
+        const connectPath = import_node_path43.default.join(config.dataDir, "connect.txt");
         import_node_fs29.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
       } catch {
       }
@@ -41455,7 +42245,7 @@ ${bar}
   };
 }
 function migrateDropPersonsDir(dataDir) {
-  const dir = import_node_path38.default.join(dataDir, "persons");
+  const dir = import_node_path43.default.join(dataDir, "persons");
   try {
     import_node_fs29.default.rmSync(dir, { recursive: true, force: true });
   } catch {