@pmate/cli 0.25.11 → 0.27.0

package/dist/index.js

@@ -88,7 +88,7 @@ var init_namespacedRef = __esm({
 
 // src/sessionStore.ts
 function buildSessionStorePath() {
-  return import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate", "session.json");
+  return import_node_path4.default.join(import_node_os3.default.homedir(), ".pmate", "session.json");
 }
 function assertValidAppRef(appRef) {
   return parseNamespacedRef(appRef, { entityLabel: "app ref" }).fullId;
@@ -153,7 +153,7 @@ function loadSessionStore() {
 }
 function loadExistingSessionStoreOrEmpty() {
   const sessionPath = buildSessionStorePath();
-  if (!(0, import_node_fs2.existsSync)(sessionPath)) {
+  if (!(0, import_node_fs3.existsSync)(sessionPath)) {
     return {
       version: SESSION_STORE_VERSION,
       activeAppRef: DEFAULT_APP_ID,
@@ -172,10 +172,10 @@ function loadExistingSessionStoreOrEmpty() {
 }
 function loadSessionStoreWithPath() {
   const sessionPath = buildSessionStorePath();
-  if (!(0, import_node_fs2.existsSync)(sessionPath)) {
+  if (!(0, import_node_fs3.existsSync)(sessionPath)) {
     throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
   }
-  const raw = (0, import_node_fs2.readFileSync)(sessionPath, "utf8");
+  const raw = (0, import_node_fs3.readFileSync)(sessionPath, "utf8");
   const parsed = JSON.parse(raw);
   const store = normalizeStore(parsed);
   return { sessionPath, store };
@@ -265,12 +265,12 @@ function resolveReadApp(store, options) {
 }
 function writeSessionStore(store) {
   const sessionPath = buildSessionStorePath();
-  (0, import_node_fs2.mkdirSync)(import_node_path3.default.dirname(sessionPath), { recursive: true });
-  (0, import_node_fs2.writeFileSync)(sessionPath, JSON.stringify(store, null, 2), {
+  (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(sessionPath), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(sessionPath, JSON.stringify(store, null, 2), {
     mode: 384
   });
   try {
-    (0, import_node_fs2.chmodSync)(sessionPath, 384);
+    (0, import_node_fs3.chmodSync)(sessionPath, 384);
   } catch {
   }
 }
@@ -280,13 +280,13 @@ function buildMissingSessionMessage(sessionPath, app) {
   }
   return `Missing session for app ${app} in ${sessionPath}. Run "pmate login --app ${app}" first.`;
 }
-var import_node_fs2, import_node_os2, import_node_path3, DEFAULT_APP_ID, SESSION_STORE_VERSION;
+var import_node_fs3, import_node_os3, import_node_path4, DEFAULT_APP_ID, SESSION_STORE_VERSION;
 var init_sessionStore = __esm({
   "src/sessionStore.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
-    import_node_os2 = __toESM(require("os"));
-    import_node_path3 = __toESM(require("path"));
+    import_node_fs3 = require("fs");
+    import_node_os3 = __toESM(require("os"));
+    import_node_path4 = __toESM(require("path"));
     init_namespacedRef();
     DEFAULT_APP_ID = "pmate:factory";
     SESSION_STORE_VERSION = 4;
@@ -8950,14 +8950,14 @@ var init_WebsocketClientV2 = __esm({
         if (this.reconnectTimer) return;
         const base = Math.min(1e3 * 2 ** this.reconnectAttempts, this.maxBackoffMs);
         const jitter = Math.floor(Math.random() * 250);
-        const delay = base + jitter;
+        const delay2 = base + jitter;
         this.reconnectTimer = globalThis.setTimeout(() => {
           if (this.ws && this.ws.readyState === WebSocket.CONNECTING) return;
           this.reconnectTimer = void 0;
           this.reconnectAttempts++;
           logger3.log("Reconnecting... attempt", this.reconnectAttempts);
           this.init();
-        }, delay);
+        }, delay2);
       }
       handleHeartbeatTimeout() {
         this.close(false);
@@ -9570,7 +9570,56 @@ var init_AgentTaskManager = __esm({
   }
 });
 
+// node_modules/@pmate/agent-sdk/dist/promptMany.js
+async function mapWithConcurrency(inputs, concurrency, run) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error("concurrency must be a positive integer");
+  }
+  const results = new Array(inputs.length);
+  let nextIndex = 0;
+  const workers = Array.from({ length: Math.min(concurrency, inputs.length) }, async () => {
+    while (nextIndex < inputs.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      try {
+        results[index] = {
+          ok: true,
+          value: await run(inputs[index], index)
+        };
+      } catch (error) {
+        const candidate = error;
+        results[index] = {
+          ok: false,
+          error: {
+            ...typeof candidate?.code === "string" ? { code: candidate.code } : {},
+            message: typeof candidate?.message === "string" ? candidate.message : String(error)
+          }
+        };
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+var init_promptMany = __esm({
+  "node_modules/@pmate/agent-sdk/dist/promptMany.js"() {
+    "use strict";
+  }
+});
+
 // node_modules/@pmate/agent-sdk/dist/AgentClient.js
+function isPromptBatchTerminal(status) {
+  return status === "completed" || status === "failed" || status === "expired" || status === "cancelled";
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requireBatchResponse(value) {
+  if (value === null) {
+    throw new Error("LLM batch control returned an empty response");
+  }
+  return value;
+}
 function createAgentRequestBody(payload) {
   return {
     kind: "request",
@@ -9586,6 +9635,7 @@ var init_AgentClient = __esm({
     init_AgentConnectionPool();
     init_AgentTaskManager();
     init_debug();
+    init_promptMany();
     logger5 = Logger.getDebugger("AgentClient");
     DEFAULT_TIMEOUT_MS = 4e4;
     DEFAULT_STREAM_TIMEOUT_MS = 12e4;
@@ -9636,6 +9686,92 @@ var init_AgentClient = __esm({
           payload: request.payload
         });
       }
+      async promptMany(request) {
+        return mapWithConcurrency(request.requests, request.concurrency ?? 10, (item) => this.prompt(item));
+      }
+      async submitPromptBatch(request) {
+        return requireBatchResponse(await this.runInternal({
+          agentId: request.agentId,
+          payload: {
+            __pmateLlmBatch: {
+              operation: "submit",
+              items: request.items,
+              metadata: request.metadata
+            }
+          }
+        }));
+      }
+      async getPromptBatch(request) {
+        return requireBatchResponse(await this.runInternal({
+          agentId: request.agentId,
+          payload: {
+            __pmateLlmBatch: {
+              operation: "get",
+              batchId: request.batchId
+            }
+          }
+        }));
+      }
+      async getPromptBatchResults(request) {
+        return requireBatchResponse(await this.runInternal({
+          agentId: request.agentId,
+          payload: {
+            __pmateLlmBatch: {
+              operation: "results",
+              batchId: request.batchId
+            }
+          }
+        }));
+      }
+      async waitPromptBatch(request) {
+        const pollIntervalMs = request.pollIntervalMs ?? 1e4;
+        const timeoutMs = request.timeoutMs ?? 24 * 60 * 60 * 1e3;
+        if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
+          throw new Error("pollIntervalMs must be a positive number");
+        }
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+          throw new Error("timeoutMs must be a positive number");
+        }
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+          const batch = await this.getPromptBatch(request);
+          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`);
+          }
+          await delay(Math.min(pollIntervalMs, remainingMs));
+        }
+      }
+      async promptBatch(request) {
+        const submitted = await this.submitPromptBatch(request);
+        const completed = await this.waitPromptBatch({
+          agentId: request.agentId,
+          batchId: submitted.id,
+          pollIntervalMs: request.pollIntervalMs,
+          timeoutMs: request.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,
+          batchId: completed.id
+        });
+      }
+      async cancelPromptBatch(request) {
+        return requireBatchResponse(await this.runInternal({
+          agentId: request.agentId,
+          payload: {
+            __pmateLlmBatch: {
+              operation: "cancel",
+              batchId: request.batchId
+            }
+          }
+        }));
+      }
       async generateImage(request) {
         return this.runInternal({
           agentId: request.agentId,
@@ -10002,6 +10138,7 @@ var init_dist2 = __esm({
     init_AgentTaskManager();
     init_AgentService();
     init_debug();
+    init_promptMany();
     init_src5();
   }
 });
@@ -10034,7 +10171,7 @@ function unwrapAgentResult(agentId, value) {
   return value;
 }
 function resolveMimeType(filePath) {
-  const ext = import_node_path10.default.extname(filePath).toLowerCase();
+  const ext = import_node_path12.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".wav":
       return "audio/wav";
@@ -10054,12 +10191,12 @@ function resolveMimeType(filePath) {
       return "application/octet-stream";
   }
 }
-var import_node_fs6, import_node_path10, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_AGENT_PROMPT_TIMEOUT_MS, AgentLlmClient;
+var import_node_fs7, import_node_path12, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_AGENT_PROMPT_TIMEOUT_MS, AgentLlmClient;
 var init_AgentLlmClient = __esm({
   "src/llm/AgentLlmClient.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
-    import_node_path10 = __toESM(require("path"));
+    import_node_fs7 = require("fs");
+    import_node_path12 = __toESM(require("path"));
     init_dist2();
     init_sessionStore();
     DEFAULT_AGENT_API_BASE_URL = "https://agent-api.pmate.chat";
@@ -10126,7 +10263,7 @@ var init_AgentLlmClient = __esm({
             params,
             minChunkSizeBytes: 0
           });
-          const file = (0, import_node_fs6.readFileSync)(filePath);
+          const file = (0, import_node_fs7.readFileSync)(filePath);
           input.push(new Blob([file], { type: resolveMimeType(filePath) }));
           input.end();
           return await stream.finish();
@@ -10151,8 +10288,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs24 = require("fs");
-var import_node_path28 = __toESM(require("path"));
+var import_node_fs25 = require("fs");
+var import_node_path30 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -10584,8 +10721,67 @@ var ListCommandHandler = class {
 
 // src/commands/LoginCommandHandler.ts
 var import_node_child_process = require("child_process");
+var import_node_path5 = __toESM(require("path"));
 var import_node_http = require("http");
 var import_promises = require("readline/promises");
+
+// src/accessKeyFile.ts
+var import_node_fs2 = require("fs");
+var import_node_os2 = __toESM(require("os"));
+var import_node_path3 = __toESM(require("path"));
+function readAccessKeyFile(filePath, options = {}) {
+  const absolutePath = resolveFilePath(filePath, options.cwd);
+  if (!(0, import_node_fs2.existsSync)(absolutePath)) {
+    throw new Error(`Access key file not found: ${absolutePath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs2.readFileSync)(absolutePath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in ${absolutePath}: ${message}`);
+  }
+  if (!isAccessKeyFile(parsed)) {
+    throw new Error(`Invalid PMate access key file: ${absolutePath}`);
+  }
+  if (options.expectedApp && parsed.app !== options.expectedApp) {
+    throw new Error(
+      `Access key app mismatch. expected=${options.expectedApp}, received=${parsed.app}`
+    );
+  }
+  return parsed;
+}
+function scanAccessKeyFiles(app) {
+  const dir = resolveAccessKeyDir(app);
+  if (!(0, import_node_fs2.existsSync)(dir)) {
+    return [];
+  }
+  return (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".access-key.json")).map((entry) => import_node_path3.default.join(dir, entry.name)).flatMap((filePath) => {
+    try {
+      return [{ filePath, key: readAccessKeyFile(filePath, { expectedApp: app }) }];
+    } catch {
+      return [];
+    }
+  }).sort((a, b) => a.key.name.localeCompare(b.key.name) || a.filePath.localeCompare(b.filePath));
+}
+function resolveAccessKeyDir(app) {
+  return import_node_path3.default.join(homeDir(), ".pmate", "access-keys", app);
+}
+function resolveFilePath(filePath, cwd = process.cwd()) {
+  return import_node_path3.default.isAbsolute(filePath) ? filePath : import_node_path3.default.resolve(cwd, filePath);
+}
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || import_node_os2.default.homedir() || process.cwd();
+}
+function isAccessKeyFile(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return candidate.type === "pmate-access-key" && candidate.version === 1 && typeof candidate.id === "string" && !!candidate.id.trim() && typeof candidate.app === "string" && !!candidate.app.trim() && typeof candidate.name === "string" && !!candidate.name.trim() && typeof candidate.secret === "string" && !!candidate.secret.trim() && typeof candidate.expiresAt === "string" && !!candidate.expiresAt.trim() && typeof candidate.createdAt === "string" && !!candidate.createdAt.trim();
+}
+
+// src/commands/LoginCommandHandler.ts
 init_sessionStore();
 
 // src/profileClient.ts
@@ -10632,7 +10828,6 @@ function resolveAuthApiBaseUrl(value) {
 
 // src/commands/LoginCommandHandler.ts
 var AUTH_UI_BASE_URL = "https://auth.pmate.chat";
-var AUTH_API_BASE_URL = DEFAULT_AUTH_API_BASE_URL;
 var CALLBACK_PATH = "/pmate-login-callback";
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
 function buildHostedLoginUrl(redirectUrl, appId = DEFAULT_APP_ID) {
@@ -10644,6 +10839,13 @@ function buildHostedLoginUrl(redirectUrl, appId = DEFAULT_APP_ID) {
 }
 var LoginCommandHandler = class {
   async handle(args) {
+    if (args.accessKey || args.accessKeyFile || args.accessKeyScan) {
+      await this.handleAccessKeyLogin(args);
+      return;
+    }
+    await this.handleHostedLogin(args);
+  }
+  async handleHostedLogin(args) {
     const callback = await this.startCallbackServer();
     const appId = assertValidAppRef(args.app?.trim() || DEFAULT_APP_ID);
     const loginUrl = buildHostedLoginUrl(callback.redirectUrl, appId);
@@ -10671,6 +10873,7 @@ var LoginCommandHandler = class {
       const profileId = await this.resolveProfileId({
         appId,
         requestedProfileId: args.profileId,
+        selectProfile: args.selectProfile,
         profiles
       });
       savedSession = saveLoginSession({ ...loginResponse, profileId }, appId);
@@ -10683,8 +10886,28 @@ var LoginCommandHandler = class {
       );
     }
   }
+  async handleAccessKeyLogin(args) {
+    const resolved = await this.resolveAccessKeyInput(args);
+    const appId = assertValidAppRef(resolved.app);
+    const loginResponse = await this.exchangeAccessKeySession(resolved.secret, appId);
+    const profiles = await fetchProfiles({
+      token: loginResponse.token,
+      app: appId,
+      accountId: loginResponse.session.identity.accountId
+    });
+    const profileId = await this.resolveProfileId({
+      appId,
+      requestedProfileId: args.profileId,
+      selectProfile: args.selectProfile,
+      profiles
+    });
+    const savedSession = saveLoginSession({ ...loginResponse, profileId }, appId);
+    ui.success(
+      `Logged in to ${savedSession.app}. Session saved to ${savedSession.sessionPath}`
+    );
+  }
   async exchangeSession(token, appId) {
-    const response = await fetch(`${AUTH_API_BASE_URL}/session/exchange`, {
+    const response = await fetch(`${resolveAuthApiBaseUrl()}/session/exchange`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -10705,6 +10928,88 @@ var LoginCommandHandler = class {
     }
     return resp.data;
   }
+  async exchangeAccessKeySession(secret, appId) {
+    const response = await fetch(`${resolveAuthApiBaseUrl()}/access-keys/session`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${secret}`
+      },
+      body: JSON.stringify({ app: appId })
+    });
+    if (!response.ok) {
+      const detail = await response.text();
+      throw new Error(
+        `Failed to exchange access key session (${response.status}): ${detail || response.statusText}`
+      );
+    }
+    const resp = await response.json();
+    const returnedApp = resp?.data?.session?.identity?.app?.trim();
+    if (!returnedApp || returnedApp !== appId) {
+      throw new Error("Invalid access key session response: app-scoped session mismatch.");
+    }
+    return resp.data;
+  }
+  async resolveAccessKeyInput(args) {
+    if (args.accessKey) {
+      return {
+        app: args.app?.trim() || DEFAULT_APP_ID,
+        secret: args.accessKey.trim()
+      };
+    }
+    if (args.accessKeyFile) {
+      const key = readAccessKeyFile(args.accessKeyFile, {
+        expectedApp: args.app?.trim()
+      });
+      return {
+        app: args.app?.trim() || key.app,
+        secret: key.secret
+      };
+    }
+    const app = assertValidAppRef(args.app?.trim() || DEFAULT_APP_ID);
+    const candidate = await this.selectScannedAccessKey(app);
+    return {
+      app,
+      secret: candidate.key.secret
+    };
+  }
+  async selectScannedAccessKey(app) {
+    const candidates = scanAccessKeyFiles(app);
+    if (candidates.length === 0) {
+      throw new Error(
+        `No access key found for app ${app}. Run "pmate account access-key create --app ${app} ..." or "pmate login --access-key-file <path>".`
+      );
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      const files = candidates.map((candidate) => candidate.filePath).join(", ");
+      throw new Error(
+        `Multiple access keys found for app ${app}. Run "pmate login --access-key-file <path>" with one of: ${files}`
+      );
+    }
+    ui.info(`Multiple access keys found for ${app}. Select one:`);
+    candidates.forEach((candidate, index) => {
+      ui.plain(`${index + 1}. ${this.formatAccessKeyLabel(candidate)}`);
+    });
+    const rl = (0, import_promises.createInterface)({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      while (true) {
+        const answer = (await rl.question("Access key number: ")).trim();
+        const index = Number.parseInt(answer, 10);
+        if (Number.isInteger(index) && index >= 1 && index <= candidates.length) {
+          return candidates[index - 1];
+        }
+        ui.warn(`Enter a number from 1 to ${candidates.length}.`);
+      }
+    } finally {
+      rl.close();
+    }
+  }
   async resolveProfileId(input) {
     const requestedProfileId = input.requestedProfileId?.trim();
     if (requestedProfileId) {
@@ -10717,7 +11022,7 @@ var LoginCommandHandler = class {
     if (input.profiles.length === 0) {
       throw new Error(`No profile found for app ${input.appId}.`);
     }
-    if (input.profiles.length === 1) {
+    if (input.profiles.length === 1 || !input.selectProfile) {
       return input.profiles[0].id;
     }
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -10747,6 +11052,17 @@ var LoginCommandHandler = class {
       rl.close();
     }
   }
+  formatAccessKeyLabel(candidate) {
+    const key = candidate.key;
+    const parts = [
+      key.name?.trim(),
+      key.id?.trim(),
+      key.namespace?.trim(),
+      `expires ${key.expiresAt}`,
+      import_node_path5.default.relative(process.cwd(), candidate.filePath)
+    ].filter(Boolean);
+    return parts.join(" / ");
+  }
   formatProfileLabel(profile) {
     const parts = [
       profile.nickName?.trim(),
@@ -10962,8 +11278,8 @@ var import_openapi_client = require("@alicloud/openapi-client");
 var import_sts20150401 = __toESM(require("@alicloud/sts20150401"));
 var import_ali_oss = __toESM(require("ali-oss"));
 var import_node_crypto = require("crypto");
-var import_node_fs3 = require("fs");
-var import_node_path4 = __toESM(require("path"));
+var import_node_fs4 = require("fs");
+var import_node_path6 = __toESM(require("path"));
 
 // src/certs.ts
 var DEFAULT_SSL_CERT_KEY = "pmate-01";
@@ -11256,7 +11572,7 @@ var AliyunService = class {
       ])
     );
     for (const filePath of files) {
-      const relativePath = import_node_path4.default.relative(localDir, filePath);
+      const relativePath = import_node_path6.default.relative(localDir, filePath);
       const objectKey = this.toObjectKey(normalizedPrefix, relativePath);
       const contentType = this.getContentType(filePath);
       const cacheControl = this.getStaticAssetCacheControl(relativePath);
@@ -11266,7 +11582,7 @@ var AliyunService = class {
       const options = Object.keys(headers).length > 0 ? { headers } : void 0;
       const existing = existingMap.get(objectKey);
       if (existing && typeof existing.size === "number" && !cacheControl) {
-        const stat = await import_node_fs3.promises.stat(filePath);
+        const stat = await import_node_fs4.promises.stat(filePath);
         if (stat.size === existing.size) {
           const etag = this.normalizeEtag(existing.etag);
           if (etag && !etag.includes("-")) {
@@ -11291,7 +11607,7 @@ var AliyunService = class {
     if (!region) throw new Error("Missing oss.public.region in ~/.pmate/config.yaml.");
     if (!accessKeyId) throw new Error("Missing aliyun.ak in ~/.pmate/config.yaml.");
     if (!accessKeySecret) throw new Error("Missing aliyun.sk in ~/.pmate/config.yaml.");
-    if (!(0, import_node_fs3.existsSync)(localFile)) {
+    if (!(0, import_node_fs4.existsSync)(localFile)) {
       throw new Error(`File not found: ${localFile}`);
     }
     const client = new import_ali_oss.default({ region, accessKeyId, accessKeySecret, bucket });
@@ -11638,10 +11954,10 @@ var AliyunService = class {
   }
   /** Recursively collect file paths under a directory. */
   static async collectFiles(dir) {
-    const entries = await import_node_fs3.promises.readdir(dir, { withFileTypes: true });
+    const entries = await import_node_fs4.promises.readdir(dir, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-      const fullPath = import_node_path4.default.join(dir, entry.name);
+      const fullPath = import_node_path6.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...await this.collectFiles(fullPath));
       } else if (entry.isFile()) {
@@ -11690,7 +12006,7 @@ var AliyunService = class {
   static getFileMd5(filePath) {
     return new Promise((resolve, reject) => {
       const hash = (0, import_node_crypto.createHash)("md5");
-      const stream = (0, import_node_fs3.createReadStream)(filePath);
+      const stream = (0, import_node_fs4.createReadStream)(filePath);
       stream.on("data", (chunk) => {
         hash.update(chunk);
       });
@@ -11703,17 +12019,17 @@ var AliyunService = class {
     });
   }
   static toObjectKey(prefix, relativePath) {
-    const normalizedPath = relativePath.split(import_node_path4.default.sep).join("/");
+    const normalizedPath = relativePath.split(import_node_path6.default.sep).join("/");
     if (!prefix) {
       return normalizedPath;
     }
     return `${prefix}/${normalizedPath}`;
   }
   static getContentType(filePath) {
-    if (import_node_path4.default.basename(filePath).toLowerCase() === "apple-app-site-association") {
+    if (import_node_path6.default.basename(filePath).toLowerCase() === "apple-app-site-association") {
       return "application/json";
     }
-    const ext = import_node_path4.default.extname(filePath).toLowerCase();
+    const ext = import_node_path6.default.extname(filePath).toLowerCase();
     switch (ext) {
       case ".html":
         return "text/html";
@@ -11756,7 +12072,7 @@ var AliyunService = class {
   }
   static getStaticAssetCacheControl(filePath) {
     const normalized = filePath.replace(/\\/g, "/");
-    const base = import_node_path4.default.posix.basename(normalized).toLowerCase();
+    const base = import_node_path6.default.posix.basename(normalized).toLowerCase();
     if (base === "index.html" || base === "200.html" || base === "404.html" || base === "apple-app-site-association") {
       return "no-cache, no-store, must-revalidate";
     }
@@ -11973,7 +12289,7 @@ var BucketCommandHandler = class {
 };
 
 // src/commands/DeleteCommandHandler.ts
-var import_node_path5 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 
 // src/serverAddress.ts
@@ -12131,17 +12447,17 @@ var DeleteCommandHandler = class {
     });
   }
   resolveCwd(target) {
-    return target ? import_node_path5.default.resolve(process.cwd(), target) : process.cwd();
+    return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
   }
 };
 
 // src/commands/DevCommandHandler.ts
-var import_node_fs4 = require("fs");
-var import_node_path7 = __toESM(require("path"));
+var import_node_fs5 = require("fs");
+var import_node_path9 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
 
 // src/appDir.ts
-var import_node_path6 = __toESM(require("path"));
+var import_node_path8 = __toESM(require("path"));
 function normalizeRelativeDir(input, appName) {
   if (typeof input !== "string") {
     throw new Error(`Missing dir for ${appName} in .pmate.yaml`);
@@ -12154,7 +12470,7 @@ function normalizeRelativeDir(input, appName) {
   if (unixLike.startsWith("/")) {
     throw new Error(`Invalid dir for ${appName} in .pmate.yaml: must be relative`);
   }
-  const normalized = import_node_path6.default.posix.normalize(unixLike);
+  const normalized = import_node_path8.default.posix.normalize(unixLike);
   if (normalized.startsWith("../") || normalized === "..") {
     throw new Error(
       `Invalid dir for ${appName} in .pmate.yaml: must stay within repo`
@@ -12164,7 +12480,7 @@ function normalizeRelativeDir(input, appName) {
 }
 function resolveLocalAppDir(repoRoot, appName, dir) {
   const relative = normalizeRelativeDir(dir, appName);
-  return import_node_path6.default.resolve(repoRoot, relative);
+  return import_node_path8.default.resolve(repoRoot, relative);
 }
 function resolveRemoteAppDir(appName, dir) {
   return normalizeRelativeDir(dir, appName);
@@ -12187,8 +12503,8 @@ var DevCommandHandler = class {
       );
     }
     const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-    const packageJsonPath = import_node_path7.default.join(appDir, "package.json");
-    if (!(0, import_node_fs4.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path9.default.join(appDir, "package.json");
+    if (!(0, import_node_fs5.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -12202,13 +12518,13 @@ var DevCommandHandler = class {
     await this.runCommand("pnpm", ["--filter", pkgName, "run", "dev"], cwd);
   }
   resolveCwd(target) {
-    return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
+    return target ? import_node_path9.default.resolve(process.cwd(), target) : process.cwd();
   }
   loadConfig(cwd) {
     return loadAppConfig(cwd);
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs4.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs5.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -12236,8 +12552,8 @@ var DevCommandHandler = class {
 };
 
 // src/commands/OssCommandHandler.ts
-var import_node_fs5 = require("fs");
-var import_node_path8 = __toESM(require("path"));
+var import_node_fs6 = require("fs");
+var import_node_path10 = __toESM(require("path"));
 var OssCommandHandler = class _OssCommandHandler {
   static {
     this.DEFAULT_BUCKET = "parrot-static";
@@ -12254,17 +12570,17 @@ var OssCommandHandler = class _OssCommandHandler {
       }
       return;
     }
-    const resolvedFile = import_node_path8.default.resolve(process.cwd(), args.filePath);
+    const resolvedFile = import_node_path10.default.resolve(process.cwd(), args.filePath);
     this.assertFile(resolvedFile);
     const objectKey = this.normalizeObjectKey(args.objectKey);
     const bucket = this.resolveBucket(args.bucket);
     await AliyunService.uploadFile(resolvedFile, bucket, objectKey);
   }
   assertFile(filePath) {
-    if (!(0, import_node_fs5.existsSync)(filePath)) {
+    if (!(0, import_node_fs6.existsSync)(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const stat = (0, import_node_fs5.statSync)(filePath);
+    const stat = (0, import_node_fs6.statSync)(filePath);
     if (!stat.isFile()) {
       throw new Error(`Not a file: ${filePath}`);
     }
@@ -12286,7 +12602,7 @@ var OssCommandHandler = class _OssCommandHandler {
 };
 
 // src/commands/EnvCommandHandler.ts
-var import_node_path9 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 var import_node_child_process4 = require("child_process");
 
 // src/shell.ts
@@ -12370,8 +12686,8 @@ var EnvCommandHandler = class {
     ui.success(`Set ${envKey} in .env.local`, appName);
   }
   async listEnvKeys(server, repoDir, appDir, verbose) {
-    const envLocalPath = import_node_path9.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path9.default.posix.join(appDir, ".env");
+    const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
+    const envPath = import_node_path11.default.posix.join(appDir, ".env");
     if (verbose) {
       const repoPath = `$HOME/${repoDir}`;
       ui.info("Env list target", {
@@ -12464,8 +12780,8 @@ var EnvCommandHandler = class {
     }
   }
   async appendEnvLine(server, repoDir, appDir, envKey, envLine, verbose) {
-    const envLocalPath = import_node_path9.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path9.default.posix.join(appDir, ".env");
+    const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
+    const envPath = import_node_path11.default.posix.join(appDir, ".env");
     if (verbose) {
       const repoPath = `$HOME/${repoDir}`;
       ui.info("Env add target", {
@@ -12513,8 +12829,8 @@ var EnvCommandHandler = class {
     await this.runRemoteCommand(server, command);
   }
   async deleteEnvKey(server, repoDir, appDir, envKey, verbose) {
-    const envLocalPath = import_node_path9.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path9.default.posix.join(appDir, ".env");
+    const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
+    const envPath = import_node_path11.default.posix.join(appDir, ".env");
     if (verbose) {
       const repoPath = `$HOME/${repoDir}`;
       ui.info("Env delete target", {
@@ -13330,7 +13646,7 @@ var CommitCommandHandler = class {
 
 // src/commands/SummaryCommandHandler.ts
 var import_node_child_process6 = require("child_process");
-var import_node_path11 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var SummaryCommandHandler = class {
   async handle(args) {
     const cwd = this.resolveCwd(args.cwd);
@@ -13515,7 +13831,7 @@ var SummaryCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path11.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path13.default.resolve(process.cwd(), value) : process.cwd();
   }
 };
 function truncate2(value, limit) {
@@ -13528,9 +13844,9 @@ function truncate2(value, limit) {
 
 // src/commands/LinearCommandHandler.ts
 var import_node_child_process7 = require("child_process");
-var import_node_fs7 = require("fs");
-var import_node_os3 = __toESM(require("os"));
-var import_node_path12 = __toESM(require("path"));
+var import_node_fs8 = require("fs");
+var import_node_os4 = __toESM(require("os"));
+var import_node_path14 = __toESM(require("path"));
 var import_promises3 = require("readline/promises");
 var import_openai = __toESM(require("openai"));
 var import_sdk = require("@linear/sdk");
@@ -14414,15 +14730,15 @@ var LinearCommandHandler = class {
     }
   }
   getLinearSelectionPath() {
-    return import_node_path12.default.join(import_node_os3.default.homedir(), ".pmate", "linear-selection.json");
+    return import_node_path14.default.join(import_node_os4.default.homedir(), ".pmate", "linear-selection.json");
   }
   readCachedLinearSelection(cwd) {
     const selectionPath = this.getLinearSelectionPath();
-    if (!(0, import_node_fs7.existsSync)(selectionPath)) {
+    if (!(0, import_node_fs8.existsSync)(selectionPath)) {
       return void 0;
     }
     try {
-      const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
+      const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
       if (!raw) return void 0;
       const parsed = JSON.parse(raw);
       const value = parsed[cwd];
@@ -14433,12 +14749,12 @@ var LinearCommandHandler = class {
   }
   writeCachedLinearSelection(cwd, title) {
     const selectionPath = this.getLinearSelectionPath();
-    const dir = import_node_path12.default.dirname(selectionPath);
-    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+    const dir = import_node_path14.default.dirname(selectionPath);
+    (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
     let data = {};
-    if ((0, import_node_fs7.existsSync)(selectionPath)) {
+    if ((0, import_node_fs8.existsSync)(selectionPath)) {
       try {
-        const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
+        const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
         if (raw) {
           data = JSON.parse(raw);
         }
@@ -14447,7 +14763,7 @@ var LinearCommandHandler = class {
       }
     }
     data[cwd] = title;
-    (0, import_node_fs7.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
+    (0, import_node_fs8.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   }
   async lookupIssue(client, issueRef) {
@@ -14624,14 +14940,14 @@ var LinearCommandHandler = class {
     if (process.platform !== "darwin") {
       throw new Error("Screenshot capture only supports macOS.");
     }
-    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os3.default.tmpdir(), "pmate-screenshot-"));
-    const filePath = import_node_path12.default.join(dir, `screenshot-${index}.png`);
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path14.default.join(import_node_os4.default.tmpdir(), "pmate-screenshot-"));
+    const filePath = import_node_path14.default.join(dir, `screenshot-${index}.png`);
     try {
       const code = await this.run("screencapture", ["-i", "-x", filePath], true);
       if (code !== 0) {
         throw new Error("Screenshot capture canceled or failed.");
       }
-      const buffer = await import_node_fs7.promises.readFile(filePath);
+      const buffer = await import_node_fs8.promises.readFile(filePath);
       if (buffer.length === 0) {
         throw new Error("Screenshot capture produced an empty file.");
       }
@@ -14643,7 +14959,7 @@ var LinearCommandHandler = class {
       return { buffer, mime, filename: `screenshot-${index}.${extension}` };
     } finally {
       try {
-        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -14787,17 +15103,17 @@ var LinearCommandHandler = class {
     return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
   }
   async convertToPng(buffer, ext) {
-    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os3.default.tmpdir(), "pmate-"));
-    const inputPath = import_node_path12.default.join(dir, `clipboard.${ext}`);
-    const outputPath = import_node_path12.default.join(dir, "clipboard.png");
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path14.default.join(import_node_os4.default.tmpdir(), "pmate-"));
+    const inputPath = import_node_path14.default.join(dir, `clipboard.${ext}`);
+    const outputPath = import_node_path14.default.join(dir, "clipboard.png");
     try {
-      await import_node_fs7.promises.writeFile(inputPath, buffer);
+      await import_node_fs8.promises.writeFile(inputPath, buffer);
       const stderr = await this.runCapture(
         "sips",
         ["-s", "format", "png", inputPath, "--out", outputPath],
         true
       );
-      const out = await import_node_fs7.promises.readFile(outputPath);
+      const out = await import_node_fs8.promises.readFile(outputPath);
       if (this.detectImageMime(out) !== "image/png") {
         throw new Error(
           stderr?.trim() ? `Failed to convert clipboard ${ext} to PNG: ${stderr.trim()}` : `Failed to convert clipboard ${ext} to PNG.`
@@ -14806,7 +15122,7 @@ var LinearCommandHandler = class {
       return out;
     } finally {
       try {
-        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15100,7 +15416,7 @@ var LinearCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path14.default.resolve(process.cwd(), value) : process.cwd();
   }
   createOpenAiClient() {
     const config = loadPmateConfig();
@@ -15152,8 +15468,8 @@ function sleep2(ms) {
 }
 
 // src/commands/NotionCommandHandler.ts
-var import_node_fs8 = require("fs");
-var import_node_path13 = __toESM(require("path"));
+var import_node_fs9 = require("fs");
+var import_node_path15 = __toESM(require("path"));
 
 // src/services/NotionService.ts
 var NotionService = class {
@@ -15392,9 +15708,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path29, init) {
+  static async requestJson(path31, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path29}`, {
+    const response = await fetch(`${this.baseUrl}${path31}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -15492,16 +15808,16 @@ var NotionCommandHandler = class {
     if (!args.filePath) {
       return "";
     }
-    const resolved = import_node_path13.default.resolve(process.cwd(), args.filePath);
-    return (0, import_node_fs8.readFileSync)(resolved, "utf8");
+    const resolved = import_node_path15.default.resolve(process.cwd(), args.filePath);
+    return (0, import_node_fs9.readFileSync)(resolved, "utf8");
   }
 };
 
 // src/commands/QrcodeCommandHandler.ts
 var import_node_child_process8 = require("child_process");
-var import_node_fs9 = require("fs");
-var import_node_os4 = __toESM(require("os"));
-var import_node_path14 = __toESM(require("path"));
+var import_node_fs10 = require("fs");
+var import_node_os5 = __toESM(require("os"));
+var import_node_path16 = __toESM(require("path"));
 var import_promises4 = require("readline/promises");
 var import_jsqr = __toESM(require("jsqr"));
 var import_pngjs = require("pngjs");
@@ -15527,7 +15843,7 @@ var QrcodeCommandHandler = class {
       ui.success("QR code value:", value);
     } finally {
       try {
-        await import_node_fs9.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15543,13 +15859,13 @@ var QrcodeCommandHandler = class {
     } finally {
       rl.close();
     }
-    const dir = await import_node_fs9.promises.mkdtemp(import_node_path14.default.join(import_node_os4.default.tmpdir(), "pmate-qrcode-"));
-    const filePath = import_node_path14.default.join(dir, "qrcode.png");
+    const dir = await import_node_fs10.promises.mkdtemp(import_node_path16.default.join(import_node_os5.default.tmpdir(), "pmate-qrcode-"));
+    const filePath = import_node_path16.default.join(dir, "qrcode.png");
     const code = await this.run("screencapture", ["-i", "-x", filePath], true);
     if (code !== 0) {
       throw new Error("Screenshot capture canceled or failed.");
     }
-    const buffer = await import_node_fs9.promises.readFile(filePath);
+    const buffer = await import_node_fs10.promises.readFile(filePath);
     if (buffer.length === 0) {
       throw new Error("Screenshot capture produced an empty file.");
     }
@@ -15565,7 +15881,7 @@ var QrcodeCommandHandler = class {
   async decodeQr(filePath) {
     let buffer;
     try {
-      buffer = await import_node_fs9.promises.readFile(filePath);
+      buffer = await import_node_fs10.promises.readFile(filePath);
     } catch {
       return null;
     }
@@ -15823,8 +16139,8 @@ function clampNumber(value, min, max, fallback) {
 }
 
 // src/commands/QuizCommandHandler.ts
-var import_node_fs10 = require("fs");
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs11 = require("fs");
+var import_node_path17 = __toESM(require("path"));
 init_sessionStore();
 
 // src/services/QuizService.ts
@@ -16369,8 +16685,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-meta") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const metadata = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path17.default.resolve(process.cwd(), args.filePath);
+      const metadata = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       const result = await updateQuizPaperMetadata({
         apiBaseUrl,
         linkBaseUrl,
@@ -16382,8 +16698,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "append-step") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path17.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       const result = await appendQuizPaperStep({
         apiBaseUrl,
         linkBaseUrl,
@@ -16396,8 +16712,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-step") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path17.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       step.stepId = args.stepId;
       const result = await updateQuizPaperStep({
         apiBaseUrl,
@@ -16460,8 +16776,8 @@ var QuizCommandHandler = class {
       if (targetIndex < 0) {
         throw new Error(`\u672A\u627E\u5230 stepId=${args.stepId}\uFF0C\u65E0\u6CD5\u66F4\u65B0\u8BE5\u9898\u76EE\u3002`);
       }
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const nextStep = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path17.default.resolve(process.cwd(), args.filePath);
+      const nextStep = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       nextStep.stepId = args.stepId;
       const nextSteps = [...basePaper.steps];
       nextSteps[targetIndex] = nextStep;
@@ -16511,9 +16827,9 @@ var QuizCommandHandler = class {
 };
 
 // src/commands/CollectCommandHandler.ts
-var import_node_fs12 = require("fs");
-var import_node_os6 = __toESM(require("os"));
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs13 = require("fs");
+var import_node_os7 = __toESM(require("os"));
+var import_node_path19 = __toESM(require("path"));
 var import_playwright = require("playwright");
 
 // src/im1BotClient.ts
@@ -16579,13 +16895,13 @@ var Im1BotClient = class {
 
 // src/collectStore.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs11 = require("fs");
-var import_node_os5 = __toESM(require("os"));
-var import_node_path16 = __toESM(require("path"));
+var import_node_fs12 = require("fs");
+var import_node_os6 = __toESM(require("os"));
+var import_node_path18 = __toESM(require("path"));
 function resolveCollectTarget(input) {
   const endpoint = input.endpoint ?? (input.source === "cc" ? "http://localhost:9223" : "http://localhost:9222");
   const sourceKey = input.source ?? `endpoint-${(0, import_node_crypto3.createHash)("sha1").update(endpoint).digest("hex").slice(0, 8)}`;
-  const rootDir = import_node_path16.default.join(import_node_os5.default.homedir(), ".pmate", "collect", sourceKey);
+  const rootDir = import_node_path18.default.join(import_node_os6.default.homedir(), ".pmate", "collect", sourceKey);
   return { sourceKey, endpoint, rootDir };
 }
 function toThreadKey(name) {
@@ -16597,7 +16913,7 @@ function toThreadKey(name) {
 async function readStoredThread(rootDir, threadKey) {
   const filePath = getThreadMetaFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if ("messages" in parsed && Array.isArray(parsed.messages)) {
       return parsed;
@@ -16615,15 +16931,15 @@ async function writeStoredThread(rootDir, thread) {
   const metaPath = getThreadMetaFilePath(rootDir, thread.threadKey);
   const messagePath = getThreadMessagesFilePath(rootDir, thread.threadKey);
   const { messages: messages2, ...meta } = thread;
-  await import_node_fs11.promises.mkdir(import_node_path16.default.dirname(metaPath), { recursive: true });
-  await import_node_fs11.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await import_node_fs12.promises.mkdir(import_node_path18.default.dirname(metaPath), { recursive: true });
+  await import_node_fs12.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
   const body = messages2.map((message) => JSON.stringify(message)).join("\n");
-  await import_node_fs11.promises.writeFile(messagePath, `${body}${body ? "\n" : ""}`, "utf8");
+  await import_node_fs12.promises.writeFile(messagePath, `${body}${body ? "\n" : ""}`, "utf8");
 }
 async function writeStoredIndex(rootDir, index) {
-  await import_node_fs11.promises.mkdir(rootDir, { recursive: true });
-  const filePath = import_node_path16.default.join(rootDir, "index.json");
-  await import_node_fs11.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
+  await import_node_fs12.promises.mkdir(rootDir, { recursive: true });
+  const filePath = import_node_path18.default.join(rootDir, "index.json");
+  await import_node_fs12.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function diffMessages(existing, incoming) {
   const seenMessageIds = new Set(
@@ -16697,7 +17013,7 @@ function joinNormalized(values) {
 async function readStoredMessages(rootDir, threadKey) {
   const filePath = getThreadMessagesFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     return raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => normalizeStoredMessage(JSON.parse(line)));
   } catch {
     return [];
@@ -16706,20 +17022,20 @@ async function readStoredMessages(rootDir, threadKey) {
 async function readLegacyStoredThread(rootDir, threadKey) {
   const filePath = getLegacyThreadFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function getThreadMetaFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
+  return import_node_path18.default.join(rootDir, "threads", `${threadKey}.json`);
 }
 function getThreadMessagesFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.jsonl`);
+  return import_node_path18.default.join(rootDir, "threads", `${threadKey}.jsonl`);
 }
 function getLegacyThreadFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
+  return import_node_path18.default.join(rootDir, "threads", `${threadKey}.json`);
 }
 function normalizeStoredMessage(message) {
   return {
@@ -16958,7 +17274,7 @@ var CollectCommandHandler = class {
   }
   async writeSyncReport(rootDir, target, results, failures, syncedAt) {
     const syncId = toSyncId(syncedAt);
-    const reportPath = import_node_path17.default.join(rootDir, "syncs", `${syncId}.json`);
+    const reportPath = import_node_path19.default.join(rootDir, "syncs", `${syncId}.json`);
     const threadReports = results.map((result) => ({
       threadKey: result.thread.threadKey,
       threadName: result.thread.threadName,
@@ -16967,8 +17283,8 @@ var CollectCommandHandler = class {
       addedMessages: result.diff.added,
       upgradedMessages: result.diff.upgraded
     })).filter((thread) => thread.addedCount > 0 || thread.upgradedCount > 0);
-    await import_node_fs12.promises.mkdir(import_node_path17.default.dirname(reportPath), { recursive: true });
-    await import_node_fs12.promises.writeFile(
+    await import_node_fs13.promises.mkdir(import_node_path19.default.dirname(reportPath), { recursive: true });
+    await import_node_fs13.promises.writeFile(
       reportPath,
       JSON.stringify(
         {
@@ -17146,19 +17462,19 @@ async function archiveMessageImage(rootDir, attachmentRoot, threadKey, imagePath
   if (!imagePath || isExternalImageRef(imagePath)) {
     return imagePath;
   }
-  const normalized = import_node_path17.default.posix.normalize(imagePath.replace(/\\/g, "/"));
+  const normalized = import_node_path19.default.posix.normalize(imagePath.replace(/\\/g, "/"));
   if (normalized.startsWith("attachments/")) {
-    return import_node_path17.default.join(rootDir, ...normalized.split("/"));
+    return import_node_path19.default.join(rootDir, ...normalized.split("/"));
   }
-  if (normalized.startsWith("../") || import_node_path17.default.posix.isAbsolute(normalized)) {
+  if (normalized.startsWith("../") || import_node_path19.default.posix.isAbsolute(normalized)) {
     return imagePath;
   }
-  const sourcePath = import_node_path17.default.join(attachmentRoot, ...normalized.split("/"));
-  const destinationRelativePath = import_node_path17.default.posix.join("attachments", threadKey, normalized);
-  const destinationPath = import_node_path17.default.join(rootDir, ...destinationRelativePath.split("/"));
+  const sourcePath = import_node_path19.default.join(attachmentRoot, ...normalized.split("/"));
+  const destinationRelativePath = import_node_path19.default.posix.join("attachments", threadKey, normalized);
+  const destinationPath = import_node_path19.default.join(rootDir, ...destinationRelativePath.split("/"));
   try {
-    await import_node_fs12.promises.mkdir(import_node_path17.default.dirname(destinationPath), { recursive: true });
-    await import_node_fs12.promises.copyFile(sourcePath, destinationPath);
+    await import_node_fs13.promises.mkdir(import_node_path19.default.dirname(destinationPath), { recursive: true });
+    await import_node_fs13.promises.copyFile(sourcePath, destinationPath);
     return destinationPath;
   } catch {
     return imagePath;
@@ -17168,7 +17484,7 @@ function resolveLocalAttachmentRoot(sourceKey) {
   if (sourceKey !== "cc" && sourceKey !== "yelling") {
     return null;
   }
-  return import_node_path17.default.join(import_node_os6.default.homedir(), "Library", "Application Support", sourceKey, "attachments.noindex");
+  return import_node_path19.default.join(import_node_os7.default.homedir(), "Library", "Application Support", sourceKey, "attachments.noindex");
 }
 function isExternalImageRef(imagePath) {
   return /^[a-z][a-z0-9+.-]*:/i.test(imagePath);
@@ -17780,7 +18096,7 @@ function pad2(value) {
 }
 
 // src/commands/ChatRoomCommandHandler.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var ChatRoomCommandHandler = class {
   async handle(args) {
     const sdk = await loadChatSdk();
@@ -17830,8 +18146,8 @@ var ChatRoomCommandHandler = class {
     const a = await this.connect(sdk, args.botA, args.app, args.hubUrl, args.authBaseUrl);
     const b = await this.connect(sdk, args.botB, args.app, args.hubUrl, args.authBaseUrl);
     try {
-      const botA = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(args.botA, "utf8"));
-      const botB = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(args.botB, "utf8"));
+      const botA = sdk.parsePmateBotKeyJson((0, import_node_fs14.readFileSync)(args.botA, "utf8"));
+      const botB = sdk.parsePmateBotKeyJson((0, import_node_fs14.readFileSync)(args.botB, "utf8"));
       await a.requestFriend({ to: botB.name, message: "smoke friend request" });
       await b.acceptFriend({ to: botA.name, message: "smoke friend accept" });
       await a.sendDm({ to: botB.name, text: "smoke dm from a" });
@@ -17850,7 +18166,7 @@ var ChatRoomCommandHandler = class {
     if (!botPath) {
       throw new Error("Missing required option: --bot");
     }
-    const botKey = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(botPath, "utf8"));
+    const botKey = sdk.parsePmateBotKeyJson((0, import_node_fs14.readFileSync)(botPath, "utf8"));
     const client = sdk.createChatClient({ appId, botKey, hubUrl, authBaseUrl });
     await client.connect();
     return client;
@@ -17862,8 +18178,8 @@ async function loadChatSdk() {
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs14 = require("fs");
-var import_node_path18 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path20 = __toESM(require("path"));
 init_AgentLlmClient();
 init_sessionStore();
 
@@ -17896,8 +18212,8 @@ function descriptorPathSegments(descriptor) {
   return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
 }
 function buildPathUrl(baseUrl, pathSegments, query) {
-  const path29 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
-  const url = new URL(path29, baseUrl);
+  const path31 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path31, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       url.searchParams.set(key, String(value));
@@ -18354,11 +18670,11 @@ var AgentCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18369,14 +18685,14 @@ var AgentCommandHandler = class {
   readJsonObjectFile(filePath) {
     const parsed = this.readJsonFile(filePath);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+      const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
       throw new Error(`Invalid JSON in ${absolutePath}: expected an object`);
     }
     return parsed;
   }
   tryReadJsonObjectFile(filePath) {
     const absolutePath = this.resolveExistingFile(filePath);
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -18388,8 +18704,8 @@ var AgentCommandHandler = class {
     }
   }
   resolveExistingFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`File not found: ${absolutePath}`);
     }
     return absolutePath;
@@ -18473,8 +18789,8 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/RunnerCommandHandler.ts
-var import_node_fs15 = require("fs");
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs16 = require("fs");
+var import_node_path21 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
 var RunnerCommandHandler = class {
@@ -18569,11 +18885,11 @@ var RunnerCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path21.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18692,8 +19008,8 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs16 = require("fs");
-var import_node_path20 = __toESM(require("path"));
+var import_node_fs17 = require("fs");
+var import_node_path22 = __toESM(require("path"));
 var StoreCommandHandler = class {
   async handle(args) {
     if (args.scope === "namespace") {
@@ -18835,11 +19151,11 @@ var StoreCommandHandler = class {
     return payload.data ?? [];
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
+    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}`);
     }
-    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18891,14 +19207,14 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs18 = require("fs");
-var import_node_path22 = __toESM(require("path"));
+var import_node_fs19 = require("fs");
+var import_node_path24 = __toESM(require("path"));
 init_sessionStore();
 
 // src/appIcon.ts
-var import_node_fs17 = require("fs");
-var import_node_os7 = __toESM(require("os"));
-var import_node_path21 = __toESM(require("path"));
+var import_node_fs18 = require("fs");
+var import_node_os8 = __toESM(require("os"));
+var import_node_path23 = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
 init_namespacedRef();
 var ANDROID_ICON_SPECS = [
@@ -19003,13 +19319,13 @@ function createAppIconExportPlans(input) {
     if (!input.outDir) {
       throw new Error("App icon preset export requires --out-dir.");
     }
-    const outDir = import_node_path21.default.resolve(input.cwd, input.outDir);
-    (0, import_node_fs17.mkdirSync)(outDir, { recursive: true });
+    const outDir = import_node_path23.default.resolve(input.cwd, input.outDir);
+    (0, import_node_fs18.mkdirSync)(outDir, { recursive: true });
     return specs.map((spec) => ({
       width: spec.width,
       height: spec.height,
       format: "png",
-      outputPath: import_node_path21.default.join(
+      outputPath: import_node_path23.default.join(
         outDir,
         `${namespace}-${objectId}-${spec.name}-${spec.width}x${spec.height}.png`
       )
@@ -19022,8 +19338,8 @@ function createAppIconExportPlans(input) {
   if (!input.output) {
     throw new Error("Single-size app icon export requires --output.");
   }
-  const resolvedOutput = import_node_path21.default.resolve(input.cwd, input.output);
-  (0, import_node_fs17.mkdirSync)(import_node_path21.default.dirname(resolvedOutput), { recursive: true });
+  const resolvedOutput = import_node_path23.default.resolve(input.cwd, input.output);
+  (0, import_node_fs18.mkdirSync)(import_node_path23.default.dirname(resolvedOutput), { recursive: true });
   return [
     {
       width: input.width,
@@ -19037,7 +19353,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_fs17.writeFileSync)(plan.outputPath, bytes);
+    (0, import_node_fs18.writeFileSync)(plan.outputPath, bytes);
   }
 }
 async function renderAppIconVariant(input) {
@@ -19045,9 +19361,9 @@ async function renderAppIconVariant(input) {
   const bytes = await renderAppIcon(svg, input.width, input.height, input.format);
   let outputPath;
   if (input.output) {
-    outputPath = import_node_path21.default.resolve(input.cwd, input.output);
-    (0, import_node_fs17.mkdirSync)(import_node_path21.default.dirname(outputPath), { recursive: true });
-    (0, import_node_fs17.writeFileSync)(outputPath, bytes);
+    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);
   }
   if (input.name) {
     return {
@@ -19068,7 +19384,7 @@ async function renderAppIconVariant(input) {
   };
 }
 async function loadAppIconVariantFile(input) {
-  const absolutePath = import_node_path21.default.resolve(input.cwd, input.filePath);
+  const absolutePath = import_node_path23.default.resolve(input.cwd, input.filePath);
   const format = inferVariantFormatFromPath(absolutePath);
   return {
     value: input.name ? await uploadAppIconVariantAsset({
@@ -19077,7 +19393,7 @@ async function loadAppIconVariantFile(input) {
       name: input.name,
       format,
       sourcePath: absolutePath
-    }) : createImageDataUrl((0, import_node_fs17.readFileSync)(absolutePath), format),
+    }) : createImageDataUrl((0, import_node_fs18.readFileSync)(absolutePath), format),
     format,
     absolutePath
   };
@@ -19136,7 +19452,7 @@ function shouldAutoGenerateDefaultVariant(icon) {
   return looksLikeSvgMarkup(icon) || looksLikeSvgUrl(icon);
 }
 function inferVariantFormatFromPath(filePath) {
-  const ext = import_node_path21.default.extname(filePath).toLowerCase();
+  const ext = import_node_path23.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".png":
       return "png";
@@ -19207,13 +19523,13 @@ async function uploadAppIconVariantAsset(input) {
     await AliyunService.uploadFile(sourcePath, DEFAULT_APP_ICON_VARIANT_BUCKET, objectKey);
   } finally {
     if (shouldCleanup) {
-      (0, import_node_fs17.rmSync)(import_node_path21.default.dirname(sourcePath), { recursive: true, force: true });
+      (0, import_node_fs18.rmSync)(import_node_path23.default.dirname(sourcePath), { recursive: true, force: true });
     }
   }
   return `${DEFAULT_APP_ICON_VARIANT_PUBLIC_BASE_URL}/${objectKey}`;
 }
 function buildAppIconVariantObjectKey(input) {
-  return import_node_path21.default.posix.join(
+  return import_node_path23.default.posix.join(
     "apps",
     `${resolveAppIconAssetStem(input.icon, input.appRef)}-${input.name}.${extensionForIconFormat(input.format)}`
   );
@@ -19222,8 +19538,8 @@ function resolveAppIconAssetStem(icon, appRef) {
   if (icon) {
     try {
       const url = new URL(icon);
-      const ext = import_node_path21.default.posix.extname(url.pathname);
-      const basename = import_node_path21.default.posix.basename(url.pathname, ext);
+      const ext = import_node_path23.default.posix.extname(url.pathname);
+      const basename = import_node_path23.default.posix.basename(url.pathname, ext);
       const normalized = sanitizeAppIconAssetStem(basename);
       if (normalized) {
         return normalized;
@@ -19252,9 +19568,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_fs17.mkdtempSync)(import_node_path21.default.join(import_node_os7.default.tmpdir(), "pmate-app-icon-"));
-  const tempPath = import_node_path21.default.join(tempDir, import_node_path21.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
-  (0, import_node_fs17.writeFileSync)(tempPath, bytes);
+  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);
   return tempPath;
 }
 
@@ -19463,10 +19779,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19476,10 +19792,10 @@ var AppCommandHandler = class {
   }
   async preparePayload(filePath, appRef) {
     const absolutePath = this.resolveFilePath(filePath);
-    return prepareAppPayload(this.readJsonFile(filePath), import_node_path22.default.dirname(absolutePath), { appRef });
+    return prepareAppPayload(this.readJsonFile(filePath), import_node_path24.default.dirname(absolutePath), { appRef });
   }
   resolveFilePath(filePath) {
-    return import_node_path22.default.resolve(process.cwd(), filePath);
+    return import_node_path24.default.resolve(process.cwd(), filePath);
   }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
@@ -19599,18 +19915,18 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path25 = __toESM(require("path"));
+var import_node_path27 = __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_fs19 = require("fs");
-var import_node_os8 = __toESM(require("os"));
-var import_node_path23 = __toESM(require("path"));
+var import_node_fs20 = require("fs");
+var import_node_os9 = __toESM(require("os"));
+var import_node_path25 = __toESM(require("path"));
 var ANDROID_APK_BUCKET = "parrot-static";
 var ANDROID_APK_PUBLIC_BASE_URL = "https://parrot-static.pmate.chat";
 var AndroidApkReleaseService = class {
@@ -19644,7 +19960,7 @@ var AndroidApkReleaseService = class {
     }
     await AliyunService.uploadFile(apkPath, ANDROID_APK_BUCKET, objectKey);
     const sha256 = await sha256File(apkPath);
-    const size = (0, import_node_fs19.statSync)(apkPath).size;
+    const size = (0, import_node_fs20.statSync)(apkPath).size;
     const artifact = {
       serviceId: service.id,
       env: options.env,
@@ -19682,7 +19998,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_path23.default.basename(item.name, ".apk");
+      const versionName = import_node_path25.default.basename(item.name, ".apk");
       return {
         serviceId,
         env: options.env ?? "unknown",
@@ -19705,7 +20021,7 @@ var AndroidApkReleaseService = class {
     }
   }
   resolveRepoRoot(service, cwd) {
-    if (cwd) return import_node_path23.default.resolve(process.cwd(), cwd);
+    if (cwd) return import_node_path25.default.resolve(process.cwd(), cwd);
     const repository = this.getRepository(service);
     if (repository) {
       return resolveRepositoryLocalRoot(repository);
@@ -19717,8 +20033,8 @@ var AndroidApkReleaseService = class {
     if (!dir) {
       throw new Error(`Missing dir for android service ${service.id}`);
     }
-    const appDir = import_node_path23.default.resolve(repoRoot, dir);
-    if (!(0, import_node_fs19.existsSync)(appDir)) {
+    const appDir = import_node_path25.default.resolve(repoRoot, dir);
+    if (!(0, import_node_fs20.existsSync)(appDir)) {
       throw new Error(`Android app dir not found: ${appDir}`);
     }
     return appDir;
@@ -19734,11 +20050,11 @@ var AndroidApkReleaseService = class {
     return void 0;
   }
   async runGradleAssembleAndFindApk(repoRoot, appDir, variant) {
-    const gradlew = [import_node_path23.default.join(appDir, "gradlew"), import_node_path23.default.join(repoRoot, "gradlew")].find((candidate) => (0, import_node_fs19.existsSync)(candidate));
+    const gradlew = [import_node_path25.default.join(appDir, "gradlew"), import_node_path25.default.join(repoRoot, "gradlew")].find((candidate) => (0, import_node_fs20.existsSync)(candidate));
     if (!gradlew) {
       throw new Error(`Gradle wrapper not found in ${appDir} or ${repoRoot}`);
     }
-    const gradleCwd = import_node_path23.default.dirname(gradlew);
+    const gradleCwd = import_node_path25.default.dirname(gradlew);
     const normalizedVariant = variant.toLowerCase();
     const taskSuffix = `assemble${capitalize(normalizedVariant)}`;
     const tasks = [`:app:${taskSuffix}`, taskSuffix];
@@ -19806,7 +20122,7 @@ function resolveRepositoryLocalRoot(repository) {
   if (!repoName) {
     throw new Error(`Invalid repository: ${repository}`);
   }
-  return import_node_path23.default.join(import_node_os8.default.homedir(), "dev", "pmate", repoName);
+  return import_node_path25.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);
@@ -19862,42 +20178,42 @@ function parseGradleOutputMetadata(source, apkFileName) {
 }
 function bumpAndroidProjectVersion(appDir, bump) {
   const candidates = [
-    import_node_path23.default.join(appDir, "app", "build.gradle.kts"),
-    import_node_path23.default.join(appDir, "app", "build.gradle"),
-    import_node_path23.default.join(appDir, "build.gradle.kts"),
-    import_node_path23.default.join(appDir, "build.gradle")
+    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")
   ];
   for (const candidate of candidates) {
-    if (!(0, import_node_fs19.existsSync)(candidate)) continue;
-    const result = bumpAndroidGradleVersionText((0, import_node_fs19.readFileSync)(candidate, "utf8"), bump);
-    (0, import_node_fs19.writeFileSync)(candidate, result.source);
+    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);
     return { filePath: candidate, ...result };
   }
   throw new Error(`No Android Gradle version file found under ${appDir}`);
 }
 function findLatestApk(repoRoot, appDir, variant) {
   const dirs = [
-    import_node_path23.default.join(appDir, "app", "build", "outputs", "apk", variant),
-    import_node_path23.default.join(appDir, "build", "outputs", "apk", variant),
-    import_node_path23.default.join(repoRoot, "app", "build", "outputs", "apk", variant)
+    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)
   ];
   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_fs19.statSync)(b).mtimeMs - (0, import_node_fs19.statSync)(a).mtimeMs);
+  files.sort((a, b) => (0, import_node_fs20.statSync)(b).mtimeMs - (0, import_node_fs20.statSync)(a).mtimeMs);
   return files[0];
 }
 function readGradleOutputMetadata(apkPath) {
-  const metadataPath = import_node_path23.default.join(import_node_path23.default.dirname(apkPath), "output-metadata.json");
-  if (!(0, import_node_fs19.existsSync)(metadataPath)) {
+  const metadataPath = import_node_path25.default.join(import_node_path25.default.dirname(apkPath), "output-metadata.json");
+  if (!(0, import_node_fs20.existsSync)(metadataPath)) {
     throw new Error(`Gradle output metadata not found: ${metadataPath}`);
   }
-  return parseGradleOutputMetadata((0, import_node_fs19.readFileSync)(metadataPath, "utf8"), import_node_path23.default.basename(apkPath));
+  return parseGradleOutputMetadata((0, import_node_fs20.readFileSync)(metadataPath, "utf8"), import_node_path25.default.basename(apkPath));
 }
 function listApks(dir) {
-  if (!(0, import_node_fs19.existsSync)(dir)) return [];
-  return (0, import_node_fs19.readdirSync)(dir).filter((entry) => entry.endsWith(".apk")).map((entry) => import_node_path23.default.join(dir, entry)).filter((entry) => (0, import_node_fs19.statSync)(entry).isFile());
+  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());
 }
 function runCommand(command, args, cwd) {
   return new Promise((resolve, reject) => {
@@ -19931,26 +20247,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_path23.default.resolve(item));
+  const sdkRoots = [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT].filter((item) => Boolean(item)).map((item) => import_node_path25.default.resolve(item));
   for (const sdkRoot of sdkRoots) {
-    const candidates = toolName === "aapt" ? listVersionedToolCandidates(import_node_path23.default.join(sdkRoot, "build-tools"), toolName) : [
-      import_node_path23.default.join(sdkRoot, "cmdline-tools", "latest", "bin", toolName),
-      ...listVersionedToolCandidates(import_node_path23.default.join(sdkRoot, "cmdline-tools"), import_node_path23.default.join("bin", toolName)),
-      import_node_path23.default.join(sdkRoot, "tools", "bin", toolName)
+    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 match = candidates.find((candidate) => (0, import_node_fs19.existsSync)(candidate));
+    const match = candidates.find((candidate) => (0, import_node_fs20.existsSync)(candidate));
     if (match) return match;
   }
   return void 0;
 }
 function listVersionedToolCandidates(parentDir, relativeToolPath) {
-  if (!(0, import_node_fs19.existsSync)(parentDir)) return [];
-  return (0, import_node_fs19.readdirSync)(parentDir).map((entry) => import_node_path23.default.join(parentDir, entry)).filter((entry) => (0, import_node_fs19.statSync)(entry).isDirectory()).sort((a, b) => import_node_path23.default.basename(b).localeCompare(import_node_path23.default.basename(a), void 0, { numeric: true })).map((entry) => import_node_path23.default.join(entry, 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));
 }
 function sha256File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto4.createHash)("sha256");
-    const stream = (0, import_node_fs19.createReadStream)(filePath);
+    const stream = (0, import_node_fs20.createReadStream)(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -19967,9 +20283,9 @@ function capitalize(value) {
 }
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs20 = require("fs");
-var import_node_os9 = __toESM(require("os"));
-var import_node_path24 = __toESM(require("path"));
+var import_node_fs21 = require("fs");
+var import_node_os10 = __toESM(require("os"));
+var import_node_path26 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
 var import_node_readline = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
@@ -20142,8 +20458,7 @@ var ServiceRegistryClient = class {
   }
   readToken() {
     return readRequiredSession({
-      preferredApp: DEFAULT_APP_ID,
-      fallbackToActiveApp: true
+      preferredApp: DEFAULT_APP_ID
     }).token;
   }
   async request(method, pathname) {
@@ -20433,14 +20748,14 @@ var ServiceRuntimeRunner = class {
   }
   resolveRepoRoot(service, cwd) {
     if (cwd) {
-      return import_node_path24.default.resolve(process.cwd(), cwd);
+      return import_node_path26.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_path24.default.join(import_node_os9.default.homedir(), "dev", "pmate", repoName);
-        if ((0, import_node_fs20.existsSync)(candidate)) {
+        const candidate = import_node_path26.default.join(import_node_os10.default.homedir(), "dev", "pmate", repoName);
+        if ((0, import_node_fs21.existsSync)(candidate)) {
           return candidate;
         }
       }
@@ -20453,13 +20768,13 @@ var ServiceRuntimeRunner = class {
     if (!dir) {
       throw new Error(`Missing service dir for ${service.id}`);
     }
-    return import_node_path24.default.resolve(repoRoot, dir);
+    return import_node_path26.default.resolve(repoRoot, dir);
   }
   async deployVite(service, options) {
     this.assertDeployableStaticSite(service);
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const packageJsonPath = import_node_path24.default.join(appDir, "package.json");
-    if (!(0, import_node_fs20.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
+    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -20474,8 +20789,8 @@ var ServiceRuntimeRunner = class {
       this.resolveRepoRoot(service, options.cwd),
       buildEnv
     );
-    const distDir = import_node_path24.default.join(appDir, "dist");
-    if (!(0, import_node_fs20.existsSync)(distDir)) {
+    const distDir = import_node_path26.default.join(appDir, "dist");
+    if (!(0, import_node_fs21.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const site = this.getSite(service);
@@ -20488,8 +20803,8 @@ var ServiceRuntimeRunner = class {
   async deployStatic(service, options) {
     this.assertDeployableStaticSite(service);
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const srcDir = import_node_path24.default.join(appDir, "src");
-    if (!(0, import_node_fs20.existsSync)(srcDir)) {
+    const srcDir = import_node_path26.default.join(appDir, "src");
+    if (!(0, import_node_fs21.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const site = this.getSite(service);
@@ -20523,8 +20838,8 @@ var ServiceRuntimeRunner = class {
     this.validateFcConfig(service, fc);
     const repoRoot = this.resolveRepoRoot(service);
     const appDir = this.resolveLocalDir(service);
-    const packageJsonPath = import_node_path24.default.join(appDir, "package.json");
-    if (!(0, import_node_fs20.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
+    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -20577,15 +20892,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_path24.default.join(appDir, fc.configFile ?? "s.yaml");
-    if (!(0, import_node_fs20.existsSync)(configPath)) {
+    const configPath = import_node_path26.default.join(appDir, fc.configFile ?? "s.yaml");
+    if (!(0, import_node_fs21.existsSync)(configPath)) {
       throw new Error(`Missing FC config file at ${configPath}`);
     }
-    const packageJsonPath = import_node_path24.default.join(appDir, "package.json");
-    if (!(0, import_node_fs20.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
+    if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
-    const rawConfig = (0, import_node_fs20.readFileSync)(configPath, "utf8");
+    const rawConfig = (0, import_node_fs21.readFileSync)(configPath, "utf8");
     if (!rawConfig.includes(fc.functionName)) {
       throw new Error(`FC config ${configPath} does not mention functionName ${fc.functionName}`);
     }
@@ -20863,7 +21178,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_fs20.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs21.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`;
@@ -20895,11 +21210,11 @@ var ServiceRuntimeRunner = class {
     }
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
-      const packageJsonPath = import_node_path24.default.join(appDir, "package.json");
-      if (!(0, import_node_fs20.existsSync)(packageJsonPath)) {
+      const packageJsonPath = import_node_path26.default.join(appDir, "package.json");
+      if (!(0, import_node_fs21.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs20.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs21.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -21328,9 +21643,9 @@ var ServiceRuntimeRunner = class {
     return tokens;
   }
   readPathValue(source, pathExpr) {
-    const path29 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
+    const path31 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
     let cursor = source;
-    for (const segment of path29) {
+    for (const segment of path31) {
       if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
         return void 0;
       }
@@ -21373,12 +21688,12 @@ var ServiceRuntimeRunner = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path24.default.join(__dirname, "..", "templates", templateName),
-      import_node_path24.default.join(__dirname, "..", "src", "templates", templateName),
-      import_node_path24.default.join(__dirname, "templates", templateName)
+      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)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs20.existsSync)(candidate)) {
+      if ((0, import_node_fs21.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -21410,7 +21725,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs20.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs21.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -21419,7 +21734,7 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs20.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs21.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   validateFcConfig(service, fc) {
@@ -21446,8 +21761,8 @@ var ServiceRuntimeRunner = class {
     }
   }
   async ensurePnpmWorkspaceRoot(repoRoot) {
-    const workspacePath = import_node_path24.default.join(repoRoot, "pnpm-workspace.yaml");
-    if (!(0, import_node_fs20.existsSync)(workspacePath)) {
+    const workspacePath = import_node_path26.default.join(repoRoot, "pnpm-workspace.yaml");
+    if (!(0, import_node_fs21.existsSync)(workspacePath)) {
       throw new Error(`Missing pnpm-workspace.yaml at ${workspacePath}`);
     }
   }
@@ -21521,16 +21836,16 @@ var ServiceRuntimeRunner = class {
     if (!privateKeyPath) {
       throw new Error("Missing ssl.prv in ~/.pmate/config.yaml.");
     }
-    if (!(0, import_node_fs20.existsSync)(certificatePath)) {
+    if (!(0, import_node_fs21.existsSync)(certificatePath)) {
       throw new Error(`SSL certificate file not found: ${certificatePath}`);
     }
-    if (!(0, import_node_fs20.existsSync)(privateKeyPath)) {
+    if (!(0, import_node_fs21.existsSync)(privateKeyPath)) {
       throw new Error(`SSL private key file not found: ${privateKeyPath}`);
     }
     return {
       certName: host,
-      certificate: (0, import_node_fs20.readFileSync)(certificatePath, "utf8"),
-      privateKey: (0, import_node_fs20.readFileSync)(privateKeyPath, "utf8")
+      certificate: (0, import_node_fs21.readFileSync)(certificatePath, "utf8"),
+      privateKey: (0, import_node_fs21.readFileSync)(privateKeyPath, "utf8")
     };
   }
   resolveFcProtocol(fc, certConfig) {
@@ -21987,7 +22302,7 @@ var ServiceCommandHandler = class {
             format: "dotenv"
           }
         );
-        const outputPath = import_node_path25.default.resolve(process.cwd(), args.output);
+        const outputPath = import_node_path27.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);
@@ -22213,11 +22528,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_path25.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path27.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs22.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -22977,8 +23292,7 @@ var RoleCommandHandler = class {
   }
   readToken() {
     return readRequiredSession({
-      preferredApp: DEFAULT_APP_ID,
-      fallbackToActiveApp: true
+      preferredApp: DEFAULT_APP_ID
     }).token;
   }
   async request(baseUrl, token, method, pathname, body) {
@@ -23026,9 +23340,9 @@ var RoleCommandHandler = class {
 };
 
 // src/commands/AccountCommandHandler.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_crypto5 = require("crypto");
-var import_node_path26 = __toESM(require("path"));
+var import_node_path28 = __toESM(require("path"));
 init_sessionStore();
 var AccountCommandHandler = class {
   async handle(args) {
@@ -23036,9 +23350,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_fs22.mkdirSync)(import_node_path26.default.dirname(outPath), { recursive: true });
-        (0, import_node_fs22.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-        (0, import_node_fs22.chmodSync)(outPath, 384);
+        (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);
         if (!args.json) {
           ui.success(`Bot key saved to ${outPath}`);
         }
@@ -23404,8 +23718,7 @@ var AccountCommandHandler = class {
   }
   readToken() {
     return readRequiredSession({
-      preferredApp: DEFAULT_APP_ID,
-      fallbackToActiveApp: true
+      preferredApp: DEFAULT_APP_ID
     }).token;
   }
   buildAccountViewQuery(args) {
@@ -23576,10 +23889,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing visible apps input");
     }
     const absolutePath = this.resolveFilePath(args.filePath);
-    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs22.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs23.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -23593,13 +23906,13 @@ var AccountCommandHandler = class {
     return parsed;
   }
   resolveFilePath(filePath) {
-    return import_node_path26.default.resolve(process.cwd(), filePath);
+    return import_node_path28.default.resolve(process.cwd(), filePath);
   }
   resolveDefaultBotKeyPath(app, name) {
-    return import_node_path26.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
+    return import_node_path28.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
   }
   resolveDefaultAccessKeyPath(app, name) {
-    return import_node_path26.default.join(this.homeDir(), ".pmate", "access-keys", app, `${name}.access-key.json`);
+    return import_node_path28.default.join(this.homeDir(), ".pmate", "access-keys", app, `${name}.access-key.json`);
   }
   homeDir() {
     return process.env.HOME || process.env.USERPROFILE || process.cwd();
@@ -23622,10 +23935,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing bot key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
       throw new Error(`Bot key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs22.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs23.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}`);
     }
@@ -23642,10 +23955,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing access key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs23.existsSync)(absolutePath)) {
       throw new Error(`Access key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs22.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs23.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}`);
     }
@@ -23667,9 +23980,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_fs22.mkdirSync)(import_node_path26.default.dirname(outPath), { recursive: true });
-    (0, import_node_fs22.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-    (0, import_node_fs22.chmodSync)(outPath, 384);
+    (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);
   }
   renderAccessKeyCreateResult(result, asJson, out) {
     if (asJson) {
@@ -23709,16 +24022,12 @@ var AccountCommandHandler = class {
     }
   }
   async resolveLoginProfileId(login, app, authApiBaseUrl) {
-    try {
-      return await fetchDefaultProfileId({
-        token: login.token,
-        app,
-        accountId: login.session.identity.accountId,
-        authApiBaseUrl
-      });
-    } catch {
-      return login.session.identity.accessKeyId ?? login.session.identity.accountId;
-    }
+    return await fetchDefaultProfileId({
+      token: login.token,
+      app,
+      accountId: login.session.identity.accountId,
+      authApiBaseUrl
+    });
   }
   signBotChallenge(challenge, privateKey) {
     const key = (0, import_node_crypto5.createPrivateKey)({
@@ -23760,8 +24069,8 @@ function encodePathSegment2(value) {
 }
 
 // src/commands/OrgCommandHandler.ts
-var import_node_fs23 = require("fs");
-var import_node_path27 = __toESM(require("path"));
+var import_node_fs24 = require("fs");
+var import_node_path29 = __toESM(require("path"));
 init_sessionStore();
 var OrgCommandHandler = class {
   async handle(args) {
@@ -23921,8 +24230,7 @@ var OrgCommandHandler = class {
   }
   readToken() {
     return readRequiredSession({
-      preferredApp: DEFAULT_APP_ID,
-      fallbackToActiveApp: true
+      preferredApp: DEFAULT_APP_ID
     }).token;
   }
   resolveStringArrayInput(values, filePath, itemLabel) {
@@ -23932,11 +24240,11 @@ var OrgCommandHandler = class {
     if (!filePath) {
       throw new Error(`Missing ${itemLabel} input`);
     }
-    const absolutePath = import_node_path27.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs23.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_fs23.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs24.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -27332,7 +27640,7 @@ function requireValue12(tokens, option) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs24.readFileSync)(import_node_path28.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs25.readFileSync)(import_node_path30.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -27348,7 +27656,8 @@ var HELP_TEXT = [
   import_chalk4.default.bold("Commands:"),
   `  ${import_chalk4.default.cyan("list [path]")}      List apps from .pmate.yaml in the target folder`,
   `  ${import_chalk4.default.cyan("login")}            Log in and store a session in ~/.pmate/session.json`,
-  `  ${import_chalk4.default.gray("                  [--app <app-id>] [--profile-id <id>]")}`,
+  `  ${import_chalk4.default.gray("                  [--app <app-id>] [--profile-id <id>] [--select-profile]")}`,
+  `  ${import_chalk4.default.gray("                  [--access-key [secret] | --access-key-file <path>]")}`,
   `  ${import_chalk4.default.cyan("add-dns")}          Add a DNS record via Aliyun DNS`,
   `  ${import_chalk4.default.gray("                  --type <t> --value <v> --rr <rr> [--ttl <n>] [--domain <name>]")}`,
   `  ${import_chalk4.default.cyan("sts")}              Request an OSS STS token from the CI server`,
@@ -27581,6 +27890,10 @@ function parseCommandArgs(args) {
     const rest = args.rest.slice(1);
     let app;
     let profileId;
+    let accessKey;
+    let accessKeyFile;
+    let accessKeyScan = false;
+    let selectProfile = false;
     while (rest.length > 0) {
       const token = rest.shift();
       switch (token) {
@@ -27590,11 +27903,30 @@ function parseCommandArgs(args) {
         case "--profile-id":
           profileId = requireValue13(rest, token);
           break;
+        case "--access-key":
+          if (rest[0] && !rest[0].startsWith("--")) {
+            accessKey = rest.shift();
+          } else {
+            accessKeyScan = true;
+          }
+          break;
+        case "--access-key-file":
+          accessKeyFile = requireValue13(rest, token);
+          break;
+        case "--select-profile":
+          selectProfile = true;
+          break;
         default:
           throw new Error(`Unknown login option: ${token}`);
       }
     }
-    return { type: "login" /* Login */, app, profileId };
+    if (accessKey && accessKeyFile) {
+      throw new Error("--access-key and --access-key-file are mutually exclusive");
+    }
+    if (accessKeyScan && accessKeyFile) {
+      throw new Error("--access-key and --access-key-file are mutually exclusive");
+    }
+    return { type: "login" /* Login */, app, profileId, accessKey, accessKeyFile, accessKeyScan, selectProfile };
   }
   if (args.rest[0] === "add-dns") {
     return parseAddDnsArgs(args.rest.slice(1));