@pmate/cli 0.28.8 → 0.29.0

package/dist/index.js

@@ -385,12 +385,38 @@ var init_logs_types = __esm({
 });
 
 // node_modules/.pnpm/@pmate+meta@1.1.15/node_modules/@pmate/meta/src/types/message.types.ts
-var PING, PONG;
+var PING, PONG, MsgOp;
 var init_message_types = __esm({
   "node_modules/.pnpm/@pmate+meta@1.1.15/node_modules/@pmate/meta/src/types/message.types.ts"() {
     "use strict";
     PING = 1;
     PONG = 2;
+    MsgOp = /* @__PURE__ */ ((MsgOp3) => {
+      MsgOp3[MsgOp3["CHAT"] = 1] = "CHAT";
+      MsgOp3[MsgOp3["AGENT"] = 2] = "AGENT";
+      MsgOp3[MsgOp3["ACK"] = 3] = "ACK";
+      MsgOp3[MsgOp3["AUTH"] = 4] = "AUTH";
+      MsgOp3[MsgOp3["LEFT"] = 5] = "LEFT";
+      MsgOp3[MsgOp3["TEXT"] = 16] = "TEXT";
+      MsgOp3[MsgOp3["HELLO"] = 18] = "HELLO";
+      MsgOp3[MsgOp3["EMOJI"] = 19] = "EMOJI";
+      MsgOp3[MsgOp3["IMAGE"] = 20] = "IMAGE";
+      MsgOp3[MsgOp3["GROUP_NEW_PEERS"] = 24] = "GROUP_NEW_PEERS";
+      MsgOp3[MsgOp3["GROUP_REMOVE_PEERS"] = 25] = "GROUP_REMOVE_PEERS";
+      MsgOp3[MsgOp3["FRIEND_DELETE"] = 26] = "FRIEND_DELETE";
+      MsgOp3[MsgOp3["DELETE_CHAT"] = 27] = "DELETE_CHAT";
+      MsgOp3[MsgOp3["REJECT"] = 32] = "REJECT";
+      MsgOp3[MsgOp3["PIPELINE_CALL"] = 33] = "PIPELINE_CALL";
+      MsgOp3[MsgOp3["PIPELINE_ACK"] = 34] = "PIPELINE_ACK";
+      MsgOp3[MsgOp3["PIPELINE_JOIN"] = 35] = "PIPELINE_JOIN";
+      MsgOp3[MsgOp3["SYSTEM_NOTIFY"] = 36] = "SYSTEM_NOTIFY";
+      MsgOp3[MsgOp3["RECALL"] = 49] = "RECALL";
+      MsgOp3[MsgOp3["AUTH_ACK"] = 1001] = "AUTH_ACK";
+      MsgOp3[MsgOp3["AGENT_REQUEST"] = 1002] = "AGENT_REQUEST";
+      MsgOp3[MsgOp3["AGENT_RESPONSE"] = 1003] = "AGENT_RESPONSE";
+      MsgOp3[MsgOp3["LAST_POSITION"] = 8194] = "LAST_POSITION";
+      return MsgOp3;
+    })(MsgOp || {});
   }
 });
 
@@ -8858,52 +8884,52 @@ var init_AgentClient = __esm({
         await this.lease.connection.authenticate(timeoutMs);
         return true;
       }
-      async prompt(request) {
+      async prompt(request2) {
         return this.runInternal({
-          agentId: request.agentId,
-          payload: request.payload
+          agentId: request2.agentId,
+          payload: request2.payload
         });
       }
-      async promptMany(request) {
-        return mapWithConcurrency(request.requests, request.concurrency ?? 10, (item) => this.prompt(item));
+      async promptMany(request2) {
+        return mapWithConcurrency(request2.requests, request2.concurrency ?? 10, (item) => this.prompt(item));
       }
-      async submitPromptBatch(request) {
+      async submitPromptBatch(request2) {
         return requireBatchResponse(await this.runInternal({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           payload: {
             __pmateLlmBatch: {
               operation: "submit",
-              items: request.items,
-              metadata: request.metadata
+              items: request2.items,
+              metadata: request2.metadata
             }
           }
         }));
       }
-      async getPromptBatch(request) {
+      async getPromptBatch(request2) {
         return requireBatchResponse(await this.runInternal({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           payload: {
             __pmateLlmBatch: {
               operation: "get",
-              batchId: request.batchId
+              batchId: request2.batchId
             }
           }
         }));
       }
-      async getPromptBatchResults(request) {
+      async getPromptBatchResults(request2) {
         return requireBatchResponse(await this.runInternal({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           payload: {
             __pmateLlmBatch: {
               operation: "results",
-              batchId: request.batchId
+              batchId: request2.batchId
             }
           }
         }));
       }
-      async waitPromptBatch(request) {
-        const pollIntervalMs = request.pollIntervalMs ?? 1e4;
-        const timeoutMs = request.timeoutMs ?? 24 * 60 * 60 * 1e3;
+      async waitPromptBatch(request2) {
+        const pollIntervalMs = request2.pollIntervalMs ?? 1e4;
+        const timeoutMs = request2.timeoutMs ?? 24 * 60 * 60 * 1e3;
         if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
           throw new Error("pollIntervalMs must be a positive number");
         }
@@ -8912,89 +8938,89 @@ var init_AgentClient = __esm({
         }
         const deadline = Date.now() + timeoutMs;
         while (true) {
-          const batch = await this.getPromptBatch(request);
+          const batch = await this.getPromptBatch(request2);
           if (isPromptBatchTerminal(batch.status)) {
             return batch;
           }
           const remainingMs = deadline - Date.now();
           if (remainingMs <= 0) {
-            throw new Error(`Timed out waiting for prompt batch "${request.batchId}"; the server-side batch was not cancelled`);
+            throw new Error(`Timed out waiting for prompt batch "${request2.batchId}"; the server-side batch was not cancelled`);
           }
           await delay(Math.min(pollIntervalMs, remainingMs));
         }
       }
-      async promptBatch(request) {
-        const submitted = await this.submitPromptBatch(request);
+      async promptBatch(request2) {
+        const submitted = await this.submitPromptBatch(request2);
         const completed = await this.waitPromptBatch({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           batchId: submitted.id,
-          pollIntervalMs: request.pollIntervalMs,
-          timeoutMs: request.timeoutMs
+          pollIntervalMs: request2.pollIntervalMs,
+          timeoutMs: request2.timeoutMs
         });
         if (completed.status === "failed" || completed.status === "cancelled") {
           throw new Error(`Prompt batch "${completed.id}" ended with status "${completed.status}"`);
         }
         return this.getPromptBatchResults({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           batchId: completed.id
         });
       }
-      async cancelPromptBatch(request) {
+      async cancelPromptBatch(request2) {
         return requireBatchResponse(await this.runInternal({
-          agentId: request.agentId,
+          agentId: request2.agentId,
           payload: {
             __pmateLlmBatch: {
               operation: "cancel",
-              batchId: request.batchId
+              batchId: request2.batchId
             }
           }
         }));
       }
-      async generateImage(request) {
+      async generateImage(request2) {
         return this.runInternal({
-          agentId: request.agentId,
-          payload: request.payload
+          agentId: request2.agentId,
+          payload: request2.payload
         });
       }
-      async echo(request) {
+      async echo(request2) {
         return this.runInternal({
-          agentId: request.agentId,
-          payload: request.payload
+          agentId: request2.agentId,
+          payload: request2.payload
         });
       }
-      async runInternal(request) {
+      async runInternal(request2) {
         this.ensureReady();
-        const taskId = this.createTaskId(request.agentId);
-        const agent = await this.agentService.getAgentById(request.agentId);
+        const taskId = this.createTaskId(request2.agentId);
+        const agent = await this.agentService.getAgentById(request2.agentId);
         const hubTo = `@hub/${agent.type}`;
         const { waiter } = this.tasks.createTask(taskId, {
           timeoutMs: this.timeoutMs,
           failMode: "reject",
           onFail: (message) => {
-            logger5.error("Agent task failed", request.agentId, message);
+            logger5.error("Agent task failed", request2.agentId, message);
           }
         });
         const startPayload = {
           taskId,
-          agentId: request.agentId,
+          agentId: request2.agentId,
           op: 0 /* Start */,
           auth: this.auth,
           type: this.defaultRequestType,
-          ...request.payload ? { payload: request.payload } : {}
+          ...request2.payload ? { payload: request2.payload } : {}
         };
         const msg = Msg.create(this.from, hubTo, 2 /* AGENT */, createAgentRequestBody(startPayload), 0 /* PIPELINE */);
         debugLog("[agent-client] sending agent request", {
           taskId,
-          agentId: request.agentId,
+          agentId: request2.agentId,
           from: this.from,
           to: hubTo
         });
         await this.lease.connection.sendMsg(msg);
         return await waiter;
       }
-      stream(request) {
+      stream(request2) {
         this.ensureReady();
-        const taskId = this.createTaskId(request.agentId);
+        const taskId = this.createTaskId(request2.agentId);
         const { waiter, onProgress } = this.tasks.createTask(taskId, {
           timeoutMs: this.streamTimeoutMs,
           failMode: "reject",
@@ -9002,10 +9028,10 @@ var init_AgentClient = __esm({
         });
         const from = this.from;
         const connection = this.lease.connection;
-        const minChunkSizeBytes = request.minChunkSizeBytes ?? this.minChunkSizeBytes;
-        const inputStream = minChunkSizeBytes > 0 ? AsyncStream.chunkBlob(request.stream, {
+        const minChunkSizeBytes = request2.minChunkSizeBytes ?? this.minChunkSizeBytes;
+        const inputStream = minChunkSizeBytes > 0 ? AsyncStream.chunkBlob(request2.stream, {
           minBytes: minChunkSizeBytes
-        }) : request.stream;
+        }) : request2.stream;
         const outputStream = new AsyncStream();
         onProgress((data) => {
           outputStream.push({ type: "progress", data });
@@ -9037,22 +9063,22 @@ var init_AgentClient = __esm({
           outputStream.error(err2);
         });
         const startDataStream = async () => {
-          const agent = await this.agentService.getAgentById(request.agentId);
+          const agent = await this.agentService.getAgentById(request2.agentId);
           const hubTo = `@hub/${agent.type}`;
           const startMsg = Msg.create(from, hubTo, 2 /* AGENT */, createAgentRequestBody({
             taskId,
-            agentId: request.agentId,
+            agentId: request2.agentId,
             op: 0 /* Start */,
             auth: this.auth,
             type: this.defaultRequestType,
-            ...request.params ? { payload: request.params } : {}
+            ...request2.params ? { payload: request2.params } : {}
           }), 0 /* PIPELINE */);
           await connection.sendMsg(startMsg);
           for await (const payload of inputStream) {
             const dataType = payload instanceof Blob ? payload.type || this.defaultBinaryType : payload instanceof Uint8Array || payload instanceof ArrayBuffer ? this.defaultBinaryType : typeof payload === "string" ? "text" : this.defaultRequestType;
             const body = {
               taskId,
-              agentId: request.agentId,
+              agentId: request2.agentId,
               op: 1 /* Data */,
               auth: this.auth,
               type: dataType,
@@ -9063,7 +9089,7 @@ var init_AgentClient = __esm({
           }
           const endMsg = Msg.create(from, hubTo, 2 /* AGENT */, createAgentRequestBody({
             taskId,
-            agentId: request.agentId,
+            agentId: request2.agentId,
             op: 2 /* End */,
             auth: this.auth,
             type: this.defaultRequestType
@@ -9466,8 +9492,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs26 = require("fs");
-var import_node_path31 = __toESM(require("path"));
+var import_node_fs28 = require("fs");
+var import_node_path33 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -10257,8 +10283,8 @@ var LoginCommandHandler = class {
       rejectToken = reject;
     });
     const openSockets = /* @__PURE__ */ new Set();
-    const server = (0, import_node_http.createServer)((request, response) => {
-      this.handleCallbackRequest(request, response, resolveToken, rejectToken);
+    const server = (0, import_node_http.createServer)((request2, response) => {
+      this.handleCallbackRequest(request2, response, resolveToken, rejectToken);
     });
     server.on("connection", (socket) => {
       openSockets.add(socket);
@@ -10301,8 +10327,8 @@ var LoginCommandHandler = class {
       close
     };
   }
-  handleCallbackRequest(request, response, resolveToken, rejectToken) {
-    const url = new URL(request.url || "/", "http://127.0.0.1");
+  handleCallbackRequest(request2, response, resolveToken, rejectToken) {
+    const url = new URL(request2.url || "/", "http://127.0.0.1");
     if (url.pathname !== CALLBACK_PATH) {
       response.statusCode = 404;
       response.end("Not found");
@@ -10581,14 +10607,14 @@ var AliyunService = class {
       regionId: userConfig.aliyun?.region?.trim() || "cn-hangzhou"
     });
     const client = new import_alidns20150109.default(sdkConfig);
-    const request = new import_alidns20150109.AddDomainRecordRequest({
+    const request2 = new import_alidns20150109.AddDomainRecordRequest({
       domainName: input.domainName,
       RR: input.rr,
       type: input.type,
       value: input.value,
       TTL: input.ttl ?? 600
     });
-    await client.addDomainRecord(request);
+    await client.addDomainRecord(request2);
   }
   /** Get existing CNAME record value for an RR, if any. */
   static async getCnameRecordValue(domainName, rr) {
@@ -10603,14 +10629,14 @@ var AliyunService = class {
       regionId: userConfig.aliyun?.region?.trim() || "cn-hangzhou"
     });
     const client = new import_alidns20150109.default(sdkConfig);
-    const request = new import_alidns20150109.DescribeDomainRecordsRequest({
+    const request2 = new import_alidns20150109.DescribeDomainRecordsRequest({
       domainName,
       RRKeyWord: rr,
       type: "CNAME",
       searchMode: "ADVANCED",
       pageSize: 500
     });
-    const response = await client.describeDomainRecords(request);
+    const response = await client.describeDomainRecords(request2);
     const records = response.body?.domainRecords?.record ?? [];
     const normalizedRr = rr.toLowerCase();
     const match = records.find(
@@ -10631,14 +10657,14 @@ var AliyunService = class {
       regionId: userConfig.aliyun?.region?.trim() || "cn-hangzhou"
     });
     const client = new import_alidns20150109.default(sdkConfig);
-    const request = new import_alidns20150109.DescribeDomainRecordsRequest({
+    const request2 = new import_alidns20150109.DescribeDomainRecordsRequest({
       domainName,
       RRKeyWord: rr,
       type: "A",
       searchMode: "ADVANCED",
       pageSize: 500
     });
-    const response = await client.describeDomainRecords(request);
+    const response = await client.describeDomainRecords(request2);
     const records = response.body?.domainRecords?.record ?? [];
     const normalizedRr = rr.toLowerCase();
     const match = records.find(
@@ -10659,14 +10685,14 @@ var AliyunService = class {
       regionId: userConfig.aliyun?.region?.trim() || "cn-hangzhou"
     });
     const client = new import_alidns20150109.default(sdkConfig);
-    const request = new import_alidns20150109.DescribeDomainRecordsRequest({
+    const request2 = new import_alidns20150109.DescribeDomainRecordsRequest({
       domainName: input.domainName,
       RRKeyWord: input.rr,
       type: input.type,
       searchMode: "ADVANCED",
       pageSize: 500
     });
-    const response = await client.describeDomainRecords(request);
+    const response = await client.describeDomainRecords(request2);
     const records = response.body?.domainRecords?.record ?? [];
     const normalizedRr = input.rr.toLowerCase();
     const normalizedType = input.type.toUpperCase();
@@ -10893,19 +10919,19 @@ var AliyunService = class {
         weight: "10"
       }
     ]);
-    const request = new import_cdn20180510.AddCdnDomainRequest({
+    const request2 = new import_cdn20180510.AddCdnDomainRequest({
       domainName,
       cdnType: "web",
       sources
     });
-    await client.addCdnDomain(request);
+    await client.addCdnDomain(request2);
     ui.success(`CDN domain created: ${domainName}`);
   }
   /** Fetch the CDN CNAME for a domain. */
   static async getCdnCname(domainName) {
     const client = this.createCdnClient();
-    const request = new import_cdn20180510.DescribeDomainCnameRequest({ domainName });
-    const response = await client.describeDomainCname(request);
+    const request2 = new import_cdn20180510.DescribeDomainCnameRequest({ domainName });
+    const response = await client.describeDomainCname(request2);
     const data = response.body?.cnameDatas?.data ?? [];
     const match = data.find((item) => item?.domain === domainName) ?? data[0];
     return match?.cname;
@@ -10936,7 +10962,7 @@ var AliyunService = class {
   static async refreshCdnSslCertificate(domainName, certKey = DEFAULT_SSL_CERT_KEY) {
     const client = this.createCdnClient();
     const cert = resolveSslCert(certKey);
-    const request = new import_cdn20180510.SetCdnDomainSSLCertificateRequest({
+    const request2 = new import_cdn20180510.SetCdnDomainSSLCertificateRequest({
       domainName,
       certType: "cas",
       certName: cert.certName,
@@ -10944,7 +10970,7 @@ var AliyunService = class {
       certRegion: cert.certRegion,
       SSLProtocol: "on"
     });
-    await client.setCdnDomainSSLCertificate(request);
+    await client.setCdnDomainSSLCertificate(request2);
   }
   /** Configure a CDN 403 error page for SPA fallback. */
   static async enableSpa404Fallback(domainName) {
@@ -10961,11 +10987,11 @@ var AliyunService = class {
         ]
       }
     ]);
-    const request = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
+    const request2 = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
       domainNames: domainName,
       functions
     });
-    await client.batchSetCdnDomainConfig(request);
+    await client.batchSetCdnDomainConfig(request2);
   }
   /** Enable SPA rewrite rule for CDN. */
   static async enableSpaRewriteRule(domainName) {
@@ -10983,11 +11009,11 @@ var AliyunService = class {
         ]
       }
     ]);
-    const request = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
+    const request2 = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
       domainNames: domainName,
       functions
     });
-    await client.batchSetCdnDomainConfig(request);
+    await client.batchSetCdnDomainConfig(request2);
   }
   /** Enable SSG rewrite rule for CDN. */
   static async enableSsgRewriteRule(domainName) {
@@ -11005,11 +11031,11 @@ var AliyunService = class {
         ]
       }
     ]);
-    const request = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
+    const request2 = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
       domainNames: domainName,
       functions
     });
-    await client.batchSetCdnDomainConfig(request);
+    await client.batchSetCdnDomainConfig(request2);
   }
   /** Enable OSS private bucket origin auth for CDN. */
   static async enableOssPrivateBucketOrigin(domainName) {
@@ -11020,11 +11046,11 @@ var AliyunService = class {
         functionArgs: [{ argName: "private_oss_auth", argValue: "on" }]
       }
     ]);
-    const request = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
+    const request2 = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
       domainNames: domainName,
       functions
     });
-    await client.batchSetCdnDomainConfig(request);
+    await client.batchSetCdnDomainConfig(request2);
   }
   /** Configure default cache rules for CDN. */
   static async setDefaultCacheRules(domainName) {
@@ -11071,11 +11097,11 @@ var AliyunService = class {
         ]
       }
     ]);
-    const request = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
+    const request2 = new import_cdn20180510.BatchSetCdnDomainConfigRequest({
       domainNames: domainName,
       functions
     });
-    await client.batchSetCdnDomainConfig(request);
+    await client.batchSetCdnDomainConfig(request2);
   }
   /** Check if an OSS bucket exists. */
   static async bucketExists(client, bucketName) {
@@ -11103,8 +11129,8 @@ var AliyunService = class {
   }
   /** Check CDN domain status. */
   static async getCdnDomainStatus(client, domainName) {
-    const request = new import_cdn20180510.CheckCdnDomainExistRequest({ domainName });
-    const response = await client.checkCdnDomainExist(request);
+    const request2 = new import_cdn20180510.CheckCdnDomainExistRequest({ domainName });
+    const response = await client.checkCdnDomainExist(request2);
     return response.body?.status;
   }
   /** Build the OSS regional domain for a bucket. */
@@ -14896,9 +14922,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path32, init) {
+  static async requestJson(path34, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path32}`, {
+    const response = await fetch(`${this.baseUrl}${path34}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -17494,8 +17520,8 @@ function descriptorPathSegments(descriptor) {
   return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
 }
 function buildPathUrl(baseUrl, pathSegments, query) {
-  const path32 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
-  const url = new URL(path32, baseUrl);
+  const path34 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path34, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       url.searchParams.set(key, String(value));
@@ -18237,6 +18263,284 @@ var RunnerCommandHandler = class {
   }
 };
 
+// src/commands/RegistryResourceCommandHandler.ts
+var import_node_fs17 = require("fs");
+var import_node_path22 = __toESM(require("path"));
+init_sessionStore();
+var RegistryResourceCommandHandler = class {
+  async handle(args) {
+    const resource = args.type === "function" ? "functions" : "workers";
+    const singular = args.type === "function" ? "Function" : "Worker";
+    const baseUrl = (args.baseUrl || process.env.PMATE_AGENT_API_BASE_URL || "https://agent-api.pmate.chat").replace(/\/+$/, "");
+    const token = readRequiredSession({ preferredApp: DEFAULT_APP_ID }).token;
+    if (args.action === "list") {
+      const query = args.namespace ? `?namespace=${encodeURIComponent(args.namespace)}` : "";
+      const { items } = await request(baseUrl, token, "GET", `/v1/${resource}${query}`);
+      if (args.json) ui.plain(JSON.stringify(items, null, 2));
+      else if (!items.length) ui.warn(`No ${resource} found.`);
+      else for (const item of items) ui.info(item.id, { status: item.status, ...item.payload });
+      return;
+    }
+    const resourcePath = `/v1/${resource}/${encodeURIComponent(args.namespace)}${args.action === "create" ? "" : `/${encodeURIComponent(args.name)}`}`;
+    if (args.action === "get" || args.action === "view") {
+      const record2 = await request(baseUrl, token, "GET", resourcePath);
+      ui.plain(JSON.stringify(record2, null, 2));
+      return;
+    }
+    if (args.action === "create" || args.action === "update") {
+      const payload = readJson(args.filePath);
+      const record2 = await request(baseUrl, token, args.action === "create" ? "POST" : "PUT", resourcePath, payload);
+      ui.success(`${args.action === "create" ? "Created" : "Updated"} ${singular.toLowerCase()} ${record2.id}`);
+      if (args.json) ui.plain(JSON.stringify(record2, null, 2));
+      return;
+    }
+    const record = await request(baseUrl, token, "DELETE", resourcePath);
+    ui.success(`Disabled ${singular.toLowerCase()} ${record.id}`);
+    if (args.json) ui.plain(JSON.stringify(record, null, 2));
+  }
+};
+function readJson(filePath) {
+  const absolutePath = import_node_path22.default.resolve(process.cwd(), filePath);
+  if (!(0, import_node_fs17.existsSync)(absolutePath)) throw new Error(`JSON file not found: ${absolutePath}`);
+  return JSON.parse((0, import_node_fs17.readFileSync)(absolutePath, "utf8"));
+}
+async function request(baseUrl, token, method, pathname, body) {
+  const response = await fetch(`${baseUrl}${pathname}`, {
+    method,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  const payload = await response.json();
+  if (!response.ok || !payload.success) throw new Error(payload.message || `Request failed with status ${response.status}`);
+  return payload.data;
+}
+
+// src/commands/CallCommandHandler.ts
+var import_node_fs18 = require("fs");
+var import_node_path23 = __toESM(require("path"));
+
+// node_modules/.pnpm/@pmate+hub-sdk@0.2.1/node_modules/@pmate/hub-sdk/dist/HubClient.js
+init_src();
+init_src3();
+var DEFAULT_TIMEOUT_MS2 = 4e4;
+var HubClient = class {
+  options;
+  ws;
+  profileId;
+  token;
+  authenticated = false;
+  calls = /* @__PURE__ */ new Map();
+  timeoutMs;
+  connectWaiter;
+  authWaiter;
+  constructor(options) {
+    this.options = options;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  }
+  async login(options) {
+    this.close();
+    this.profileId = options.profileId;
+    this.token = options.token;
+    this.connectWaiter = deferred();
+    this.authWaiter = deferred();
+    const ws = new WebsocketClientV2(ensureWsProtocol(this.options.baseUrl));
+    this.ws = ws;
+    const stream = ws.getStream();
+    void this.consume(stream);
+    const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+    await withTimeout(this.connectWaiter.promise, timeoutMs, "Hub connection timed out");
+    await ws.sendMsg(Msg.create(options.profileId, "@hub", 4 /* AUTH */, {
+      token: options.token,
+      as: "user",
+      profileId: options.profileId
+    }, 0 /* PIPELINE */));
+    await withTimeout(this.authWaiter.promise, timeoutMs, "Hub authentication timed out");
+    this.authenticated = true;
+  }
+  async call(request2) {
+    if (!this.ws || !this.profileId || !this.token || !this.authenticated) {
+      throw new Error("HubClient is not logged in");
+    }
+    const callId = createCallId(request2.functionId);
+    const timeoutMs = request2.timeoutMs ?? this.timeoutMs;
+    const result = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.calls.delete(callId);
+        reject(new Error(`Function call timed out: ${request2.functionId}`));
+      }, timeoutMs);
+      this.calls.set(callId, {
+        resolve,
+        reject,
+        timer
+      });
+    });
+    const body = {
+      kind: "request",
+      callId,
+      functionId: request2.functionId,
+      input: request2.input,
+      auth: { token: this.token, profileId: this.profileId },
+      idempotencyKey: request2.idempotencyKey,
+      timeoutMs
+    };
+    try {
+      await this.ws.sendMsg(Msg.create(this.profileId, "@hub", MsgOp.CALL, body, 0 /* PIPELINE */));
+    } catch (error) {
+      this.rejectCall(callId, error instanceof Error ? error : new Error(String(error)));
+    }
+    return result;
+  }
+  close() {
+    this.ws?.close();
+    this.ws = void 0;
+    this.authenticated = false;
+    this.token = void 0;
+    this.connectWaiter?.reject(new Error("HubClient closed before connection completed"));
+    this.authWaiter?.reject(new Error("HubClient closed before authentication completed"));
+    this.connectWaiter = void 0;
+    this.authWaiter = void 0;
+    for (const callId of this.calls.keys()) {
+      this.rejectCall(callId, new Error("HubClient closed before call completed"));
+    }
+  }
+  async consume(stream) {
+    try {
+      for await (const event of stream) {
+        this.handleEvent(event);
+      }
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      this.connectWaiter?.reject(failure);
+      this.authWaiter?.reject(failure);
+      for (const callId of this.calls.keys()) {
+        this.rejectCall(callId, failure);
+      }
+    }
+  }
+  handleEvent(event) {
+    if (event.type === "connected") {
+      if (event.data)
+        this.connectWaiter?.resolve();
+      else
+        this.authenticated = false;
+      return;
+    }
+    if (event.type === "error") {
+      const failure = new Error("Hub websocket connection failed");
+      this.connectWaiter?.reject(failure);
+      this.authWaiter?.reject(failure);
+      return;
+    }
+    if (event.type === "message")
+      this.handleMessage(event.data);
+  }
+  handleMessage(message) {
+    if (message.opcode === 3 /* ACK */) {
+      const ack = message.body;
+      if (ack.status === "ok")
+        this.authWaiter?.resolve();
+      else
+        this.authWaiter?.reject(new Error(ack.message ?? ack.code ?? "Hub authentication failed"));
+      return;
+    }
+    if (message.opcode !== MsgOp.CALL)
+      return;
+    const body = message.body;
+    if (body?.kind !== "response")
+      return;
+    this.handleResponse(body);
+  }
+  handleResponse(body) {
+    if (body.status === "pending" || body.status === "running")
+      return;
+    const call = this.calls.get(body.callId);
+    if (!call)
+      return;
+    clearTimeout(call.timer);
+    this.calls.delete(body.callId);
+    if (body.status === "completed") {
+      call.resolve(body.output);
+      return;
+    }
+    call.reject(new Error(body.error?.message ?? `Function call ${body.status}`));
+  }
+  rejectCall(callId, error) {
+    const call = this.calls.get(callId);
+    if (!call)
+      return;
+    clearTimeout(call.timer);
+    this.calls.delete(callId);
+    call.reject(error);
+  }
+};
+function createCallId(functionId) {
+  return uniqHash(`${functionId}-${Date.now()}-${Math.random()}`, "task-v1" /* Task */);
+}
+function ensureWsProtocol(baseUrl) {
+  if (/^wss?:\/\//i.test(baseUrl))
+    return baseUrl;
+  if (/^https:\/\//i.test(baseUrl))
+    return baseUrl.replace(/^https:/i, "wss:");
+  if (/^http:\/\//i.test(baseUrl))
+    return baseUrl.replace(/^http:/i, "ws:");
+  return `wss://${baseUrl}`;
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+function withTimeout(promise, timeoutMs, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+// src/commands/CallCommandHandler.ts
+init_sessionStore();
+var CallCommandHandler = class {
+  async handle(args) {
+    const session = readRequiredSession({ preferredApp: DEFAULT_APP_ID });
+    const hub = new HubClient({
+      baseUrl: args.hubBaseUrl || process.env.PMATE_HUB_BASE_URL || "https://hub.pmate.chat",
+      timeoutMs: args.timeoutMs
+    });
+    const input = args.filePath ? readJson2(args.filePath) : args.payload;
+    try {
+      await hub.login({ token: session.token, profileId: session.profileId, timeoutMs: args.timeoutMs });
+      const output = await hub.call({
+        functionId: `${args.namespace}:${args.name}`,
+        input,
+        timeoutMs: args.timeoutMs
+      });
+      if (args.json || typeof output !== "string") ui.plain(JSON.stringify(output ?? null, null, 2));
+      else ui.plain(output);
+    } finally {
+      hub.close();
+    }
+  }
+};
+function readJson2(filePath) {
+  const absolutePath = import_node_path23.default.resolve(process.cwd(), filePath);
+  if (!(0, import_node_fs18.existsSync)(absolutePath)) throw new Error(`JSON file not found: ${absolutePath}`);
+  const decoded = JSON.parse((0, import_node_fs18.readFileSync)(absolutePath, "utf8"));
+  if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+    throw new Error("Call input file must contain a JSON object");
+  }
+  return decoded;
+}
+
 // src/commands/NsCommandHandler.ts
 init_sessionStore();
 var NsCommandHandler = class {
@@ -18303,8 +18607,8 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs17 = require("fs");
-var import_node_path22 = __toESM(require("path"));
+var import_node_fs19 = require("fs");
+var import_node_path24 = __toESM(require("path"));
 init_sessionStore();
 var StoreCommandHandler = class {
   async handle(args) {
@@ -18458,11 +18762,11 @@ var StoreCommandHandler = class {
     return payload.data ?? [];
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path22.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path24.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18514,14 +18818,14 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs19 = require("fs");
-var import_node_path24 = __toESM(require("path"));
+var import_node_fs21 = require("fs");
+var import_node_path26 = __toESM(require("path"));
 init_sessionStore();
 
 // src/appIcon.ts
-var import_node_fs18 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_os8 = __toESM(require("os"));
-var import_node_path23 = __toESM(require("path"));
+var import_node_path25 = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
 init_namespacedRef();
 var ANDROID_ICON_SPECS = [
@@ -18626,13 +18930,13 @@ function createAppIconExportPlans(input) {
     if (!input.outDir) {
       throw new Error("App icon preset export requires --out-dir.");
     }
-    const outDir = import_node_path23.default.resolve(input.cwd, input.outDir);
-    (0, import_node_fs18.mkdirSync)(outDir, { recursive: true });
+    const outDir = import_node_path25.default.resolve(input.cwd, input.outDir);
+    (0, import_node_fs20.mkdirSync)(outDir, { recursive: true });
     return specs.map((spec) => ({
       width: spec.width,
       height: spec.height,
       format: "png",
-      outputPath: import_node_path23.default.join(
+      outputPath: import_node_path25.default.join(
         outDir,
         `${namespace}-${objectId}-${spec.name}-${spec.width}x${spec.height}.png`
       )
@@ -18645,8 +18949,8 @@ function createAppIconExportPlans(input) {
   if (!input.output) {
     throw new Error("Single-size app icon export requires --output.");
   }
-  const resolvedOutput = import_node_path23.default.resolve(input.cwd, input.output);
-  (0, import_node_fs18.mkdirSync)(import_node_path23.default.dirname(resolvedOutput), { recursive: true });
+  const resolvedOutput = import_node_path25.default.resolve(input.cwd, input.output);
+  (0, import_node_fs20.mkdirSync)(import_node_path25.default.dirname(resolvedOutput), { recursive: true });
   return [
     {
       width: input.width,
@@ -18660,7 +18964,7 @@ async function exportAppIcon(icon, plans) {
   const svg = await resolveAppIconSvg(icon);
   for (const plan of plans) {
     const bytes = await renderAppIcon(svg, plan.width, plan.height, plan.format);
-    (0, import_node_fs18.writeFileSync)(plan.outputPath, bytes);
+    (0, import_node_fs20.writeFileSync)(plan.outputPath, bytes);
   }
 }
 async function renderAppIconVariant(input) {
@@ -18668,9 +18972,9 @@ async function renderAppIconVariant(input) {
   const bytes = await renderAppIcon(svg, input.width, input.height, input.format);
   let outputPath;
   if (input.output) {
-    outputPath = import_node_path23.default.resolve(input.cwd, input.output);
-    (0, import_node_fs18.mkdirSync)(import_node_path23.default.dirname(outputPath), { recursive: true });
-    (0, import_node_fs18.writeFileSync)(outputPath, bytes);
+    outputPath = import_node_path25.default.resolve(input.cwd, input.output);
+    (0, import_node_fs20.mkdirSync)(import_node_path25.default.dirname(outputPath), { recursive: true });
+    (0, import_node_fs20.writeFileSync)(outputPath, bytes);
   }
   if (input.name) {
     return {
@@ -18691,7 +18995,7 @@ async function renderAppIconVariant(input) {
   };
 }
 async function loadAppIconVariantFile(input) {
-  const absolutePath = import_node_path23.default.resolve(input.cwd, input.filePath);
+  const absolutePath = import_node_path25.default.resolve(input.cwd, input.filePath);
   const format = inferVariantFormatFromPath(absolutePath);
   return {
     value: input.name ? await uploadAppIconVariantAsset({
@@ -18700,7 +19004,7 @@ async function loadAppIconVariantFile(input) {
       name: input.name,
       format,
       sourcePath: absolutePath
-    }) : createImageDataUrl((0, import_node_fs18.readFileSync)(absolutePath), format),
+    }) : createImageDataUrl((0, import_node_fs20.readFileSync)(absolutePath), format),
     format,
     absolutePath
   };
@@ -18759,7 +19063,7 @@ function shouldAutoGenerateDefaultVariant(icon) {
   return looksLikeSvgMarkup(icon) || looksLikeSvgUrl(icon);
 }
 function inferVariantFormatFromPath(filePath) {
-  const ext = import_node_path23.default.extname(filePath).toLowerCase();
+  const ext = import_node_path25.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".png":
       return "png";
@@ -18830,13 +19134,13 @@ async function uploadAppIconVariantAsset(input) {
     await AliyunService.uploadFile(sourcePath, DEFAULT_APP_ICON_VARIANT_BUCKET, objectKey);
   } finally {
     if (shouldCleanup) {
-      (0, import_node_fs18.rmSync)(import_node_path23.default.dirname(sourcePath), { recursive: true, force: true });
+      (0, import_node_fs20.rmSync)(import_node_path25.default.dirname(sourcePath), { recursive: true, force: true });
     }
   }
   return `${DEFAULT_APP_ICON_VARIANT_PUBLIC_BASE_URL}/${objectKey}`;
 }
 function buildAppIconVariantObjectKey(input) {
-  return import_node_path23.default.posix.join(
+  return import_node_path25.default.posix.join(
     "apps",
     `${resolveAppIconAssetStem(input.icon, input.appRef)}-${input.name}.${extensionForIconFormat(input.format)}`
   );
@@ -18845,8 +19149,8 @@ function resolveAppIconAssetStem(icon, appRef) {
   if (icon) {
     try {
       const url = new URL(icon);
-      const ext = import_node_path23.default.posix.extname(url.pathname);
-      const basename = import_node_path23.default.posix.basename(url.pathname, ext);
+      const ext = import_node_path25.default.posix.extname(url.pathname);
+      const basename = import_node_path25.default.posix.basename(url.pathname, ext);
       const normalized = sanitizeAppIconAssetStem(basename);
       if (normalized) {
         return normalized;
@@ -18875,9 +19179,9 @@ function writeTempAppIconVariantFile(objectKey, format, bytes) {
   if (!bytes) {
     throw new Error("App icon variant upload requires bytes or a source file.");
   }
-  const tempDir = (0, import_node_fs18.mkdtempSync)(import_node_path23.default.join(import_node_os8.default.tmpdir(), "pmate-app-icon-"));
-  const tempPath = import_node_path23.default.join(tempDir, import_node_path23.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
-  (0, import_node_fs18.writeFileSync)(tempPath, bytes);
+  const tempDir = (0, import_node_fs20.mkdtempSync)(import_node_path25.default.join(import_node_os8.default.tmpdir(), "pmate-app-icon-"));
+  const tempPath = import_node_path25.default.join(tempDir, import_node_path25.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
+  (0, import_node_fs20.writeFileSync)(tempPath, bytes);
   return tempPath;
 }
 
@@ -19086,10 +19390,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19099,10 +19403,10 @@ var AppCommandHandler = class {
   }
   async preparePayload(filePath, appRef) {
     const absolutePath = this.resolveFilePath(filePath);
-    return prepareAppPayload(this.readJsonFile(filePath), import_node_path24.default.dirname(absolutePath), { appRef });
+    return prepareAppPayload(this.readJsonFile(filePath), import_node_path26.default.dirname(absolutePath), { appRef });
   }
   resolveFilePath(filePath) {
-    return import_node_path24.default.resolve(process.cwd(), filePath);
+    return import_node_path26.default.resolve(process.cwd(), filePath);
   }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
@@ -19222,18 +19526,18 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs22 = require("fs");
+var import_node_fs24 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path27 = __toESM(require("path"));
+var import_node_path29 = __toESM(require("path"));
 var import_node_child_process11 = require("child_process");
 var import_promises6 = require("readline/promises");
 
 // src/services/AndroidApkReleaseService.ts
 var import_node_child_process9 = require("child_process");
 var import_node_crypto4 = require("crypto");
-var import_node_fs20 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_os9 = __toESM(require("os"));
-var import_node_path25 = __toESM(require("path"));
+var import_node_path27 = __toESM(require("path"));
 var ANDROID_APK_BUCKET = "parrot-static";
 var ANDROID_APK_PUBLIC_BASE_URL = "https://parrot-static.pmate.chat";
 var AndroidApkReleaseService = class {
@@ -19267,7 +19571,7 @@ var AndroidApkReleaseService = class {
     }
     await AliyunService.uploadFile(apkPath, ANDROID_APK_BUCKET, objectKey);
     const sha256 = await sha256File(apkPath);
-    const size = (0, import_node_fs20.statSync)(apkPath).size;
+    const size = (0, import_node_fs22.statSync)(apkPath).size;
     const artifact = {
       serviceId: service.id,
       env: options.env,
@@ -19301,15 +19605,15 @@ var AndroidApkReleaseService = class {
       minimumVersionCode: options.minimumVersionCode
     });
     const objectKey = buildAndroidLatestManifestObjectKey(service.namespace, service.name);
-    const tempDir = (0, import_node_fs20.mkdtempSync)(import_node_path25.default.join(import_node_os9.default.tmpdir(), "pmate-apk-latest-"));
-    const manifestPath = import_node_path25.default.join(tempDir, "latest.json");
+    const tempDir = (0, import_node_fs22.mkdtempSync)(import_node_path27.default.join(import_node_os9.default.tmpdir(), "pmate-apk-latest-"));
+    const manifestPath = import_node_path27.default.join(tempDir, "latest.json");
     try {
-      (0, import_node_fs20.writeFileSync)(manifestPath, `${JSON.stringify(manifest, null, 2)}
+      (0, import_node_fs22.writeFileSync)(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
       await AliyunService.uploadFile(manifestPath, ANDROID_APK_BUCKET, objectKey);
       ui.success(`Published Android update manifest ${ANDROID_APK_PUBLIC_BASE_URL}/${objectKey}`);
     } finally {
-      (0, import_node_fs20.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs22.rmSync)(tempDir, { recursive: true, force: true });
     }
   }
   async list(service, options) {
@@ -19325,7 +19629,7 @@ var AndroidApkReleaseService = class {
     const prefix = `apks/${service.namespace}/${service.name}`;
     const objects = await AliyunService.listObjects(ANDROID_APK_BUCKET, prefix);
     return objects.filter((item) => item.name.endsWith(".apk")).map((item) => {
-      const versionName = import_node_path25.default.basename(item.name, ".apk");
+      const versionName = import_node_path27.default.basename(item.name, ".apk");
       return {
         serviceId,
         env: options.env ?? "unknown",
@@ -19348,7 +19652,7 @@ var AndroidApkReleaseService = class {
     }
   }
   resolveRepoRoot(service, cwd) {
-    if (cwd) return import_node_path25.default.resolve(process.cwd(), cwd);
+    if (cwd) return import_node_path27.default.resolve(process.cwd(), cwd);
     const repository = this.getRepository(service);
     if (repository) {
       return resolveRepositoryLocalRoot(repository);
@@ -19360,8 +19664,8 @@ var AndroidApkReleaseService = class {
     if (!dir) {
       throw new Error(`Missing dir for android service ${service.id}`);
     }
-    const appDir = import_node_path25.default.resolve(repoRoot, dir);
-    if (!(0, import_node_fs20.existsSync)(appDir)) {
+    const appDir = import_node_path27.default.resolve(repoRoot, dir);
+    if (!(0, import_node_fs22.existsSync)(appDir)) {
       throw new Error(`Android app dir not found: ${appDir}`);
     }
     return appDir;
@@ -19377,11 +19681,11 @@ var AndroidApkReleaseService = class {
     return void 0;
   }
   async runGradleAssembleAndFindApk(repoRoot, appDir, variant) {
-    const gradlew = [import_node_path25.default.join(appDir, "gradlew"), import_node_path25.default.join(repoRoot, "gradlew")].find((candidate) => (0, import_node_fs20.existsSync)(candidate));
+    const gradlew = [import_node_path27.default.join(appDir, "gradlew"), import_node_path27.default.join(repoRoot, "gradlew")].find((candidate) => (0, import_node_fs22.existsSync)(candidate));
     if (!gradlew) {
       throw new Error(`Gradle wrapper not found in ${appDir} or ${repoRoot}`);
     }
-    const gradleCwd = import_node_path25.default.dirname(gradlew);
+    const gradleCwd = import_node_path27.default.dirname(gradlew);
     const normalizedVariant = variant.toLowerCase();
     const taskSuffix = `assemble${capitalize(normalizedVariant)}`;
     const tasks = [`:app:${taskSuffix}`, taskSuffix];
@@ -19469,7 +19773,7 @@ function resolveRepositoryLocalRoot(repository) {
   if (!repoName) {
     throw new Error(`Invalid repository: ${repository}`);
   }
-  return import_node_path25.default.join(import_node_os9.default.homedir(), "dev", "pmate", repoName);
+  return import_node_path27.default.join(import_node_os9.default.homedir(), "dev", "pmate", repoName);
 }
 function bumpAndroidGradleVersionText(source, bump) {
   const versionNameMatch = source.match(/(^\s*versionName\s+["'])([^"']+)(["']\s*$)/m) ?? source.match(/(^\s*versionName\s*=\s*["'])([^"']+)(["']\s*$)/m);
@@ -19525,42 +19829,42 @@ function parseGradleOutputMetadata(source, apkFileName) {
 }
 function bumpAndroidProjectVersion(appDir, bump) {
   const candidates = [
-    import_node_path25.default.join(appDir, "app", "build.gradle.kts"),
-    import_node_path25.default.join(appDir, "app", "build.gradle"),
-    import_node_path25.default.join(appDir, "build.gradle.kts"),
-    import_node_path25.default.join(appDir, "build.gradle")
+    import_node_path27.default.join(appDir, "app", "build.gradle.kts"),
+    import_node_path27.default.join(appDir, "app", "build.gradle"),
+    import_node_path27.default.join(appDir, "build.gradle.kts"),
+    import_node_path27.default.join(appDir, "build.gradle")
   ];
   for (const candidate of candidates) {
-    if (!(0, import_node_fs20.existsSync)(candidate)) continue;
-    const result = bumpAndroidGradleVersionText((0, import_node_fs20.readFileSync)(candidate, "utf8"), bump);
-    (0, import_node_fs20.writeFileSync)(candidate, result.source);
+    if (!(0, import_node_fs22.existsSync)(candidate)) continue;
+    const result = bumpAndroidGradleVersionText((0, import_node_fs22.readFileSync)(candidate, "utf8"), bump);
+    (0, import_node_fs22.writeFileSync)(candidate, result.source);
     return { filePath: candidate, ...result };
   }
   throw new Error(`No Android Gradle version file found under ${appDir}`);
 }
 function findLatestApk(repoRoot, appDir, variant) {
   const dirs = [
-    import_node_path25.default.join(appDir, "app", "build", "outputs", "apk", variant),
-    import_node_path25.default.join(appDir, "build", "outputs", "apk", variant),
-    import_node_path25.default.join(repoRoot, "app", "build", "outputs", "apk", variant)
+    import_node_path27.default.join(appDir, "app", "build", "outputs", "apk", variant),
+    import_node_path27.default.join(appDir, "build", "outputs", "apk", variant),
+    import_node_path27.default.join(repoRoot, "app", "build", "outputs", "apk", variant)
   ];
   const files = dirs.flatMap((dir) => listApks(dir));
   if (files.length === 0) {
     throw new Error(`Cannot find APK output for variant ${variant}`);
   }
-  files.sort((a, b) => (0, import_node_fs20.statSync)(b).mtimeMs - (0, import_node_fs20.statSync)(a).mtimeMs);
+  files.sort((a, b) => (0, import_node_fs22.statSync)(b).mtimeMs - (0, import_node_fs22.statSync)(a).mtimeMs);
   return files[0];
 }
 function readGradleOutputMetadata(apkPath) {
-  const metadataPath = import_node_path25.default.join(import_node_path25.default.dirname(apkPath), "output-metadata.json");
-  if (!(0, import_node_fs20.existsSync)(metadataPath)) {
+  const metadataPath = import_node_path27.default.join(import_node_path27.default.dirname(apkPath), "output-metadata.json");
+  if (!(0, import_node_fs22.existsSync)(metadataPath)) {
     throw new Error(`Gradle output metadata not found: ${metadataPath}`);
   }
-  return parseGradleOutputMetadata((0, import_node_fs20.readFileSync)(metadataPath, "utf8"), import_node_path25.default.basename(apkPath));
+  return parseGradleOutputMetadata((0, import_node_fs22.readFileSync)(metadataPath, "utf8"), import_node_path27.default.basename(apkPath));
 }
 function listApks(dir) {
-  if (!(0, import_node_fs20.existsSync)(dir)) return [];
-  return (0, import_node_fs20.readdirSync)(dir).filter((entry) => entry.endsWith(".apk")).map((entry) => import_node_path25.default.join(dir, entry)).filter((entry) => (0, import_node_fs20.statSync)(entry).isFile());
+  if (!(0, import_node_fs22.existsSync)(dir)) return [];
+  return (0, import_node_fs22.readdirSync)(dir).filter((entry) => entry.endsWith(".apk")).map((entry) => import_node_path27.default.join(dir, entry)).filter((entry) => (0, import_node_fs22.statSync)(entry).isFile());
 }
 function runCommand(command, args, cwd) {
   return new Promise((resolve, reject) => {
@@ -19594,26 +19898,26 @@ async function runAndroidSdkToolCapture(toolName, args) {
   return runCommandCapture(toolPath, args);
 }
 function findAndroidSdkTool(toolName) {
-  const sdkRoots = [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT].filter((item) => Boolean(item)).map((item) => import_node_path25.default.resolve(item));
+  const sdkRoots = [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT].filter((item) => Boolean(item)).map((item) => import_node_path27.default.resolve(item));
   for (const sdkRoot of sdkRoots) {
-    const candidates = toolName === "aapt" ? listVersionedToolCandidates(import_node_path25.default.join(sdkRoot, "build-tools"), toolName) : [
-      import_node_path25.default.join(sdkRoot, "cmdline-tools", "latest", "bin", toolName),
-      ...listVersionedToolCandidates(import_node_path25.default.join(sdkRoot, "cmdline-tools"), import_node_path25.default.join("bin", toolName)),
-      import_node_path25.default.join(sdkRoot, "tools", "bin", toolName)
+    const candidates = toolName === "aapt" ? listVersionedToolCandidates(import_node_path27.default.join(sdkRoot, "build-tools"), toolName) : [
+      import_node_path27.default.join(sdkRoot, "cmdline-tools", "latest", "bin", toolName),
+      ...listVersionedToolCandidates(import_node_path27.default.join(sdkRoot, "cmdline-tools"), import_node_path27.default.join("bin", toolName)),
+      import_node_path27.default.join(sdkRoot, "tools", "bin", toolName)
     ];
-    const match = candidates.find((candidate) => (0, import_node_fs20.existsSync)(candidate));
+    const match = candidates.find((candidate) => (0, import_node_fs22.existsSync)(candidate));
     if (match) return match;
   }
   return void 0;
 }
 function listVersionedToolCandidates(parentDir, relativeToolPath) {
-  if (!(0, import_node_fs20.existsSync)(parentDir)) return [];
-  return (0, import_node_fs20.readdirSync)(parentDir).map((entry) => import_node_path25.default.join(parentDir, entry)).filter((entry) => (0, import_node_fs20.statSync)(entry).isDirectory()).sort((a, b) => import_node_path25.default.basename(b).localeCompare(import_node_path25.default.basename(a), void 0, { numeric: true })).map((entry) => import_node_path25.default.join(entry, relativeToolPath));
+  if (!(0, import_node_fs22.existsSync)(parentDir)) return [];
+  return (0, import_node_fs22.readdirSync)(parentDir).map((entry) => import_node_path27.default.join(parentDir, entry)).filter((entry) => (0, import_node_fs22.statSync)(entry).isDirectory()).sort((a, b) => import_node_path27.default.basename(b).localeCompare(import_node_path27.default.basename(a), void 0, { numeric: true })).map((entry) => import_node_path27.default.join(entry, relativeToolPath));
 }
 function sha256File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto4.createHash)("sha256");
-    const stream = (0, import_node_fs20.createReadStream)(filePath);
+    const stream = (0, import_node_fs22.createReadStream)(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -19630,9 +19934,9 @@ function capitalize(value) {
 }
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs21 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_os10 = __toESM(require("os"));
-var import_node_path26 = __toESM(require("path"));
+var import_node_path28 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
 var import_node_readline = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
@@ -20122,14 +20426,14 @@ var ServiceRuntimeRunner = class {
   }
   resolveRepoRoot(service, cwd) {
     if (cwd) {
-      return import_node_path26.default.resolve(process.cwd(), cwd);
+      return import_node_path28.default.resolve(process.cwd(), cwd);
     }
     const repository = this.getType(service) === "vite" || this.getType(service) === "static" ? this.getRepoStaticSite(service).repository.trim() : this.getType(service) === "fc" ? this.getFc(service).repository?.trim() : this.getType(service) === "ios" || this.getType(service) === "android" ? void 0 : this.getNetwork(service).repository?.trim();
     if (repository) {
       const repoName = repository.replace(/\/+$/, "").split("/").pop()?.replace(/\.git$/i, "");
       if (repoName) {
-        const candidate = import_node_path26.default.join(import_node_os10.default.homedir(), "dev", "pmate", repoName);
-        if ((0, import_node_fs21.existsSync)(candidate)) {
+        const candidate = import_node_path28.default.join(import_node_os10.default.homedir(), "dev", "pmate", repoName);
+        if ((0, import_node_fs23.existsSync)(candidate)) {
           return candidate;
         }
       }
@@ -20142,13 +20446,13 @@ var ServiceRuntimeRunner = class {
     if (!dir) {
       throw new Error(`Missing service dir for ${service.id}`);
     }
-    return import_node_path26.default.resolve(repoRoot, dir);
+    return import_node_path28.default.resolve(repoRoot, dir);
   }
   async deployVite(service, options) {
     this.assertDeployableStaticSite(service);
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
-    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path28.default.join(appDir, "package.json");
+    if (!(0, import_node_fs23.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -20163,8 +20467,8 @@ var ServiceRuntimeRunner = class {
       this.resolveRepoRoot(service, options.cwd),
       buildEnv
     );
-    const distDir = import_node_path26.default.join(appDir, "dist");
-    if (!(0, import_node_fs21.existsSync)(distDir)) {
+    const distDir = import_node_path28.default.join(appDir, "dist");
+    if (!(0, import_node_fs23.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const site = this.getSite(service);
@@ -20177,8 +20481,8 @@ var ServiceRuntimeRunner = class {
   async deployStatic(service, options) {
     this.assertDeployableStaticSite(service);
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const srcDir = import_node_path26.default.join(appDir, "src");
-    if (!(0, import_node_fs21.existsSync)(srcDir)) {
+    const srcDir = import_node_path28.default.join(appDir, "src");
+    if (!(0, import_node_fs23.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const site = this.getSite(service);
@@ -20212,8 +20516,8 @@ var ServiceRuntimeRunner = class {
     this.validateFcConfig(service, fc);
     const repoRoot = this.resolveRepoRoot(service);
     const appDir = this.resolveLocalDir(service);
-    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
-    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path28.default.join(appDir, "package.json");
+    if (!(0, import_node_fs23.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -20266,15 +20570,15 @@ var ServiceRuntimeRunner = class {
     const repoRoot = this.resolveRepoRoot(service, options.cwd);
     const appDir = this.resolveLocalDir(service, options.cwd);
     await this.ensurePnpmWorkspaceRoot(repoRoot);
-    const configPath = import_node_path26.default.join(appDir, fc.configFile ?? "s.yaml");
-    if (!(0, import_node_fs21.existsSync)(configPath)) {
+    const configPath = import_node_path28.default.join(appDir, fc.configFile ?? "s.yaml");
+    if (!(0, import_node_fs23.existsSync)(configPath)) {
       throw new Error(`Missing FC config file at ${configPath}`);
     }
-    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
-    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path28.default.join(appDir, "package.json");
+    if (!(0, import_node_fs23.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
-    const rawConfig = (0, import_node_fs21.readFileSync)(configPath, "utf8");
+    const rawConfig = (0, import_node_fs23.readFileSync)(configPath, "utf8");
     if (!rawConfig.includes(fc.functionName)) {
       throw new Error(`FC config ${configPath} does not mention functionName ${fc.functionName}`);
     }
@@ -20552,7 +20856,7 @@ var ServiceRuntimeRunner = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = exposeType === "websocket" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs21.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs23.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.${("domain" in network ? network.domain?.trim() : void 0) || "pmate.chat"}`;
       const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
       const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
@@ -20584,11 +20888,11 @@ var ServiceRuntimeRunner = class {
     }
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
-      const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
-      if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
+      const packageJsonPath = import_node_path28.default.join(appDir, "package.json");
+      if (!(0, import_node_fs23.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs21.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs23.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -21017,9 +21321,9 @@ var ServiceRuntimeRunner = class {
     return tokens;
   }
   readPathValue(source, pathExpr) {
-    const path32 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
+    const path34 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
     let cursor = source;
-    for (const segment of path32) {
+    for (const segment of path34) {
       if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
         return void 0;
       }
@@ -21062,12 +21366,12 @@ var ServiceRuntimeRunner = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path26.default.join(__dirname, "..", "templates", templateName),
-      import_node_path26.default.join(__dirname, "..", "src", "templates", templateName),
-      import_node_path26.default.join(__dirname, "templates", templateName)
+      import_node_path28.default.join(__dirname, "..", "templates", templateName),
+      import_node_path28.default.join(__dirname, "..", "src", "templates", templateName),
+      import_node_path28.default.join(__dirname, "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs21.existsSync)(candidate)) {
+      if ((0, import_node_fs23.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -21099,7 +21403,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs21.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs23.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -21108,7 +21412,7 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs21.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs23.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   validateFcConfig(service, fc) {
@@ -21135,8 +21439,8 @@ var ServiceRuntimeRunner = class {
     }
   }
   async ensurePnpmWorkspaceRoot(repoRoot) {
-    const workspacePath = import_node_path26.default.join(repoRoot, "pnpm-workspace.yaml");
-    if (!(0, import_node_fs21.existsSync)(workspacePath)) {
+    const workspacePath = import_node_path28.default.join(repoRoot, "pnpm-workspace.yaml");
+    if (!(0, import_node_fs23.existsSync)(workspacePath)) {
       throw new Error(`Missing pnpm-workspace.yaml at ${workspacePath}`);
     }
   }
@@ -21210,16 +21514,16 @@ var ServiceRuntimeRunner = class {
     if (!privateKeyPath) {
       throw new Error("Missing ssl.prv in ~/.pmate/config.yaml.");
     }
-    if (!(0, import_node_fs21.existsSync)(certificatePath)) {
+    if (!(0, import_node_fs23.existsSync)(certificatePath)) {
       throw new Error(`SSL certificate file not found: ${certificatePath}`);
     }
-    if (!(0, import_node_fs21.existsSync)(privateKeyPath)) {
+    if (!(0, import_node_fs23.existsSync)(privateKeyPath)) {
       throw new Error(`SSL private key file not found: ${privateKeyPath}`);
     }
     return {
       certName: host,
-      certificate: (0, import_node_fs21.readFileSync)(certificatePath, "utf8"),
-      privateKey: (0, import_node_fs21.readFileSync)(privateKeyPath, "utf8")
+      certificate: (0, import_node_fs23.readFileSync)(certificatePath, "utf8"),
+      privateKey: (0, import_node_fs23.readFileSync)(privateKeyPath, "utf8")
     };
   }
   resolveFcProtocol(fc, certConfig) {
@@ -21678,7 +21982,7 @@ var ServiceCommandHandler = class {
             format: "dotenv"
           }
         );
-        const outputPath = import_node_path27.default.resolve(process.cwd(), args.output);
+        const outputPath = import_node_path29.default.resolve(process.cwd(), args.output);
         await (0, import_promises5.writeFile)(outputPath, payload.content, "utf8");
         ui.success(`Wrote env file for ${args.appId} to ${outputPath}`);
         this.renderJson({ ...payload, output: outputPath }, args.json);
@@ -21904,11 +22208,11 @@ var ServiceCommandHandler = class {
     return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path27.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path29.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs24.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs22.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs24.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -22716,9 +23020,9 @@ var RoleCommandHandler = class {
 };
 
 // src/commands/AccountCommandHandler.ts
-var import_node_fs23 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_crypto5 = require("crypto");
-var import_node_path28 = __toESM(require("path"));
+var import_node_path30 = __toESM(require("path"));
 init_sessionStore();
 var AccountCommandHandler = class {
   async handle(args) {
@@ -22726,9 +23030,9 @@ var AccountCommandHandler = class {
       case "bot-keygen": {
         const keyFile = this.generateBotKeyFile(args.app, args.name);
         const outPath = args.out ? this.resolveFilePath(args.out) : this.resolveDefaultBotKeyPath(args.app, args.name);
-        (0, import_node_fs23.mkdirSync)(import_node_path28.default.dirname(outPath), { recursive: true });
-        (0, import_node_fs23.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-        (0, import_node_fs23.chmodSync)(outPath, 384);
+        (0, import_node_fs25.mkdirSync)(import_node_path30.default.dirname(outPath), { recursive: true });
+        (0, import_node_fs25.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
+        (0, import_node_fs25.chmodSync)(outPath, 384);
         if (!args.json) {
           ui.success(`Bot key saved to ${outPath}`);
         }
@@ -23264,10 +23568,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing visible apps input");
     }
     const absolutePath = this.resolveFilePath(args.filePath);
-    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs25.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs23.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs25.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -23281,13 +23585,13 @@ var AccountCommandHandler = class {
     return parsed;
   }
   resolveFilePath(filePath) {
-    return import_node_path28.default.resolve(process.cwd(), filePath);
+    return import_node_path30.default.resolve(process.cwd(), filePath);
   }
   resolveDefaultBotKeyPath(app, name) {
-    return import_node_path28.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
+    return import_node_path30.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
   }
   resolveDefaultAccessKeyPath(app, name) {
-    return import_node_path28.default.join(this.homeDir(), ".pmate", "access-keys", app, `${name}.access-key.json`);
+    return import_node_path30.default.join(this.homeDir(), ".pmate", "access-keys", app, `${name}.access-key.json`);
   }
   homeDir() {
     return process.env.HOME || process.env.USERPROFILE || process.cwd();
@@ -23310,10 +23614,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing bot key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs25.existsSync)(absolutePath)) {
       throw new Error(`Bot key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs23.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs25.readFileSync)(absolutePath, "utf8"));
     if (parsed.type !== "pmate-bot-key" || parsed.version !== 1 || parsed.algorithm !== "ed25519" || !parsed.publicKey || !parsed.privateKey) {
       throw new Error(`Invalid PMate bot key file: ${absolutePath}`);
     }
@@ -23330,10 +23634,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing access key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs25.existsSync)(absolutePath)) {
       throw new Error(`Access key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs23.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs25.readFileSync)(absolutePath, "utf8"));
     if (parsed.type !== "pmate-access-key" || parsed.version !== 1 || !parsed.id || !parsed.app || !parsed.secret || !parsed.expiresAt) {
       throw new Error(`Invalid PMate access key file: ${absolutePath}`);
     }
@@ -23355,9 +23659,9 @@ var AccountCommandHandler = class {
       createdAt: result.key.createdAt
     };
     const outPath = out ? this.resolveFilePath(out) : this.resolveDefaultAccessKeyPath(result.key.app, result.key.name);
-    (0, import_node_fs23.mkdirSync)(import_node_path28.default.dirname(outPath), { recursive: true });
-    (0, import_node_fs23.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-    (0, import_node_fs23.chmodSync)(outPath, 384);
+    (0, import_node_fs25.mkdirSync)(import_node_path30.default.dirname(outPath), { recursive: true });
+    (0, import_node_fs25.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
+    (0, import_node_fs25.chmodSync)(outPath, 384);
   }
   renderAccessKeyCreateResult(result, asJson, out) {
     if (asJson) {
@@ -23442,8 +23746,8 @@ function encodePathSegment2(value) {
 }
 
 // src/commands/OrgCommandHandler.ts
-var import_node_fs24 = require("fs");
-var import_node_path29 = __toESM(require("path"));
+var import_node_fs26 = require("fs");
+var import_node_path31 = __toESM(require("path"));
 init_sessionStore();
 var OrgCommandHandler = class {
   async handle(args) {
@@ -23613,11 +23917,11 @@ var OrgCommandHandler = class {
     if (!filePath) {
       throw new Error(`Missing ${itemLabel} input`);
     }
-    const absolutePath = import_node_path29.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs24.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path31.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs26.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs24.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs26.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -23688,9 +23992,9 @@ function encodePathSegment3(value) {
 }
 
 // src/commands/HostCommandHandler.ts
-var import_node_fs25 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_os11 = require("os");
-var import_node_path30 = __toESM(require("path"));
+var import_node_path32 = __toESM(require("path"));
 var import_node_child_process13 = require("child_process");
 var BLOCK_START = "# >>> pmate host env >>>";
 var BLOCK_END = "# <<< pmate host env <<<";
@@ -24322,6 +24626,101 @@ function requireValue2(tokens, optionName) {
   return value;
 }
 
+// src/registryResourceCommandParser.ts
+init_namespacedRef();
+function parseFunctionArgs(tokens) {
+  return parseRegistryArgs(tokens, "function" /* Function */, "function");
+}
+function parseWorkerArgs(tokens) {
+  return parseRegistryArgs(tokens, "worker" /* Worker */, "worker");
+}
+function parseRegistryArgs(tokens, type, label) {
+  const rest = [...tokens];
+  const action = rest.shift();
+  if (!action || !["list", "get", "view", "create", "update", "delete"].includes(action)) {
+    throw new Error(`Use: ${label} list|get|view|create|update|delete`);
+  }
+  let baseUrl;
+  let json = false;
+  let namespace;
+  let name;
+  let filePath;
+  if (["get", "view", "update", "delete"].includes(action)) {
+    const ref = rest.shift();
+    if (!ref) throw new Error(`Missing ${label} ref`);
+    const parsed = parseNamespacedRef(ref, { entityLabel: `${label} ref` });
+    namespace = parsed.namespace;
+    name = parsed.objectId;
+  } else if (action === "create" && rest[0] && !rest[0].startsWith("-")) {
+    namespace = rest.shift();
+  }
+  namespace ??= "pmate";
+  while (rest.length) {
+    const option = rest.shift();
+    const value = () => {
+      const next = rest.shift();
+      if (!next || next.startsWith("-")) throw new Error(`Missing value for ${option}`);
+      return next;
+    };
+    if (option === "--namespace" || option === "--ns") namespace = value();
+    else if (option === "--base-url") baseUrl = value();
+    else if (option === "--file") filePath = value();
+    else if (option === "--json") json = true;
+    else throw new Error(`Unknown ${label} option: ${option}`);
+  }
+  if ((action === "create" || action === "update") && !filePath) {
+    throw new Error(`Missing required option --file for ${label} ${action}`);
+  }
+  return { type, action, namespace, name, filePath, baseUrl, json };
+}
+
+// src/callCommandParser.ts
+init_namespacedRef();
+function parseCallArgs(tokens) {
+  const rest = [...tokens];
+  const ref = rest.shift();
+  if (!ref) throw new Error("Usage: call <namespace:functionId> [--payload <json>|--file <path>]");
+  const parsed = parseNamespacedRef(ref, { entityLabel: "function ref" });
+  let payload;
+  let filePath;
+  let hubBaseUrl;
+  let timeoutMs;
+  let json = false;
+  while (rest.length) {
+    const option = rest.shift();
+    const value = () => {
+      const next = rest.shift();
+      if (!next || next.startsWith("-")) throw new Error(`Missing value for ${option}`);
+      return next;
+    };
+    if (option === "--payload") {
+      const decoded = JSON.parse(value());
+      if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new Error("--payload must be a JSON object");
+      }
+      payload = decoded;
+    } else if (option === "--file") filePath = value();
+    else if (option === "--hub-base-url") hubBaseUrl = value();
+    else if (option === "--timeout-ms") timeoutMs = Number.parseInt(value(), 10);
+    else if (option === "--json") json = true;
+    else throw new Error(`Unknown call option: ${option}`);
+  }
+  if (payload && filePath) throw new Error("Provide only one of --payload or --file");
+  if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1)) {
+    throw new Error("--timeout-ms must be a positive integer");
+  }
+  return {
+    type: "call" /* Call */,
+    namespace: parsed.namespace,
+    name: parsed.objectId,
+    payload,
+    filePath,
+    hubBaseUrl,
+    timeoutMs,
+    json
+  };
+}
+
 // src/nsCommandParser.ts
 var DEFAULT_CHAIN = "pmate";
 function parseNsArgs(tokens) {
@@ -27286,7 +27685,7 @@ function requireValue13(tokens, option) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs26.readFileSync)(import_node_path31.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs28.readFileSync)(import_node_path33.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -27398,6 +27797,12 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  update <ns:objectId> --file <path> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  delete <ns:objectId> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  list defaults to all namespaces; create defaults to namespace: pmate; default base URL: https://agent-api.pmate.chat")}`,
+  `  ${import_chalk4.default.cyan("function")}         Manage Function Registry entries`,
+  `  ${import_chalk4.default.gray("                  list|get|view|create|update|delete [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.cyan("worker")}           Manage Worker Registry entries`,
+  `  ${import_chalk4.default.gray("                  list|get|view|create|update|delete [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.cyan("call")}             Call a Function through Hub`,
+  `  ${import_chalk4.default.gray("                  <namespace:functionId> [--payload <json>|--file <path>] [--timeout-ms <n>] [--json]")}`,
   `  ${import_chalk4.default.cyan("ns")}               Manage registered namespaces`,
   `  ${import_chalk4.default.gray("                  list [--chain <chain>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  get <namespace> [--chain <chain>] [--base-url <url>] [--json]")}`,
@@ -27644,6 +28049,15 @@ function parseCommandArgs(args) {
   if (args.rest[0] === "runner") {
     return parseRunnerArgs(args.rest.slice(1));
   }
+  if (args.rest[0] === "function") {
+    return parseFunctionArgs(args.rest.slice(1));
+  }
+  if (args.rest[0] === "worker") {
+    return parseWorkerArgs(args.rest.slice(1));
+  }
+  if (args.rest[0] === "call") {
+    return parseCallArgs(args.rest.slice(1));
+  }
   if (args.rest[0] === "ns" || args.rest[0] === "namespace") {
     return parseNsArgs(args.rest.slice(1));
   }
@@ -29353,6 +29767,17 @@ async function main() {
         await handler.handle(commandArgs);
         return;
       }
+      case "function" /* Function */:
+      case "worker" /* Worker */: {
+        const handler = new RegistryResourceCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
+      case "call" /* Call */: {
+        const handler = new CallCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
       case "ns" /* Ns */: {
         const handler = new NsCommandHandler();
         await handler.handle(commandArgs);