@pmate/cli 0.13.3 → 0.14.0

package/README.md

@@ -149,9 +149,15 @@ pmate linear pr --account work
 
 ## Auth session
 
-`pmate login` stores a session token in `~/.pmate/session.json`. Use `--app <app-id>`
-to authenticate against a specific app; the default remains `@pmate/cli`. Commands like
-`pmate sts` require this session; if it is missing, log in first.
+`pmate login` stores sessions in `~/.pmate/session.json`. The file now keeps a
+multi-app session registry keyed by app id, so logging into one app no longer
+overwrites another app's session. Use `--app <app-id>` to authenticate against
+a specific app; the default remains `@pmate/cli`.
+
+Notes:
+- Existing single-session files are migrated automatically on first read.
+- Platform commands such as `pmate sts`, `pmate agent`, and `pmate app` still
+  default to the `@pmate/cli` session.
 
 ## Notion config
 

package/dist/index.js

@@ -34,6 +34,149 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/sessionStore.ts
+function buildSessionStorePath() {
+  return import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate", "session.json");
+}
+function saveLoginSession(session, requestedApp = DEFAULT_APP_ID) {
+  const store = loadExistingSessionStoreOrEmpty();
+  const app = resolveStoredAppId(session, requestedApp);
+  const nextSession = {
+    ...session,
+    app,
+    session: {
+      ...session.session,
+      ...session.session.app ? {} : { app }
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  store.sessions[app] = nextSession;
+  store.activeApp = app;
+  writeSessionStore(store);
+  return {
+    app,
+    sessionPath: buildSessionStorePath()
+  };
+}
+function readRequiredSession(options) {
+  const { sessionPath, store } = loadSessionStoreWithPath();
+  const resolvedApp = resolveReadApp(store, options);
+  const session = store.sessions[resolvedApp];
+  if (!session) {
+    throw new Error(buildMissingSessionMessage(sessionPath, resolvedApp));
+  }
+  const token = session.token?.trim();
+  if (!token) {
+    throw new Error(`Missing token in ${sessionPath}. Run "pmate login --app ${resolvedApp}" again.`);
+  }
+  return {
+    ...session,
+    token
+  };
+}
+function loadSessionStore() {
+  return loadSessionStoreWithPath().store;
+}
+function loadExistingSessionStoreOrEmpty() {
+  const sessionPath = buildSessionStorePath();
+  if (!(0, import_node_fs2.existsSync)(sessionPath)) {
+    return {
+      version: SESSION_STORE_VERSION,
+      activeApp: DEFAULT_APP_ID,
+      sessions: {}
+    };
+  }
+  return loadSessionStore();
+}
+function loadSessionStoreWithPath() {
+  const sessionPath = buildSessionStorePath();
+  if (!(0, import_node_fs2.existsSync)(sessionPath)) {
+    throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
+  }
+  const raw = (0, import_node_fs2.readFileSync)(sessionPath, "utf8");
+  const parsed = JSON.parse(raw);
+  const store = normalizeStore(parsed);
+  const nextRaw = JSON.stringify(store, null, 2);
+  if (nextRaw !== raw.trim()) {
+    writeSessionStore(store);
+  }
+  return { sessionPath, store };
+}
+function normalizeStore(value) {
+  if (isSessionStore(value)) {
+    return {
+      version: SESSION_STORE_VERSION,
+      activeApp: value.activeApp || DEFAULT_APP_ID,
+      sessions: value.sessions || {}
+    };
+  }
+  const legacy = value;
+  const app = resolveStoredAppId(legacy, legacy.session?.app || legacy.app || DEFAULT_APP_ID);
+  return {
+    version: SESSION_STORE_VERSION,
+    activeApp: app,
+    sessions: {
+      [app]: {
+        ...legacy,
+        app,
+        session: {
+          ...legacy.session,
+          ...legacy.session?.app ? {} : { app }
+        },
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+}
+function isSessionStore(value) {
+  return !!value && typeof value === "object" && "version" in value && "sessions" in value && typeof value.sessions === "object";
+}
+function resolveStoredAppId(session, fallbackApp) {
+  return session.session?.app?.trim() || session.app?.trim() || fallbackApp.trim() || DEFAULT_APP_ID;
+}
+function resolveReadApp(store, options) {
+  const requestedApp = options?.app?.trim();
+  if (requestedApp) {
+    return requestedApp;
+  }
+  const preferredApp = options?.preferredApp?.trim();
+  if (preferredApp && store.sessions[preferredApp]) {
+    return preferredApp;
+  }
+  if (options?.fallbackToActiveApp && store.activeApp && store.sessions[store.activeApp]) {
+    return store.activeApp;
+  }
+  return preferredApp || store.activeApp || DEFAULT_APP_ID;
+}
+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), {
+    mode: 384
+  });
+  try {
+    (0, import_node_fs2.chmodSync)(sessionPath, 384);
+  } catch {
+  }
+}
+function buildMissingSessionMessage(sessionPath, app) {
+  if (app === DEFAULT_APP_ID) {
+    return `Missing ${DEFAULT_APP_ID} session in ${sessionPath}. Run "pmate login" first.`;
+  }
+  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 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"));
+    DEFAULT_APP_ID = "@pmate/cli";
+    SESSION_STORE_VERSION = 2;
+  }
+});
+
 // node_modules/.pnpm/@pmate+meta@1.1.2/node_modules/@pmate/meta/dist/types/account.types.js
 var require_account_types = __commonJS({
   "node_modules/.pnpm/@pmate+meta@1.1.2/node_modules/@pmate/meta/dist/types/account.types.js"(exports2) {
@@ -12406,17 +12549,9 @@ function resolveHubBaseUrl(value) {
   return (value || process.env.PMATE_AGENT_HUB_BASE_URL || DEFAULT_AGENT_HUB_BASE_URL).replace(/\/+$/, "");
 }
 function readSessionToken() {
-  const sessionPath = import_node_path13.default.join(import_node_os4.default.homedir(), ".pmate", "session.json");
-  if (!(0, import_node_fs9.existsSync)(sessionPath)) {
-    throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
-  }
-  const raw = (0, import_node_fs9.readFileSync)(sessionPath, "utf8");
-  const parsed = JSON.parse(raw);
-  const token = parsed.token?.trim();
-  if (!token) {
-    throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
-  }
-  return token;
+  return readRequiredSession({
+    preferredApp: DEFAULT_APP_ID
+  }).token;
 }
 function unwrapAgentResult(value) {
   if (!value || typeof value !== "object") {
@@ -12427,14 +12562,12 @@ function unwrapAgentResult(value) {
   }
   return value;
 }
-var import_node_fs9, import_node_os4, import_node_path13, import_agent_sdk, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_FROM, AgentLlmClient;
+var import_agent_sdk, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_FROM, AgentLlmClient;
 var init_AgentLlmClient = __esm({
   "src/llm/AgentLlmClient.ts"() {
     "use strict";
-    import_node_fs9 = require("fs");
-    import_node_os4 = __toESM(require("os"));
-    import_node_path13 = __toESM(require("path"));
     import_agent_sdk = __toESM(require_dist4());
+    init_sessionStore();
     DEFAULT_AGENT_API_BASE_URL = "https://agent-api.pmate.chat";
     DEFAULT_AGENT_HUB_BASE_URL = "https://hub.pmate.chat";
     DEFAULT_NAMESPACE = "pmate-cli";
@@ -12479,8 +12612,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs16 = require("fs");
-var import_node_path21 = __toESM(require("path"));
+var import_node_fs14 = require("fs");
+var import_node_path19 = __toESM(require("path"));
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -12910,15 +13043,12 @@ var ListCommandHandler = class {
 };
 
 // src/commands/LoginCommandHandler.ts
-var import_node_fs2 = require("fs");
 var import_node_http = require("http");
-var import_node_os2 = __toESM(require("os"));
-var import_node_path3 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
+init_sessionStore();
 var AUTH_UI_BASE_URL = "https://auth.pmate.chat";
 var AUTH_API_BASE_URL = "https://auth-api-v2.pmate.chat";
 var CALLBACK_PATH = "/pmate-login-callback";
-var DEFAULT_APP_ID = "@pmate/cli";
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
 function buildHostedLoginUrl(redirectUrl, appId = DEFAULT_APP_ID) {
   const url = new URL(AUTH_UI_BASE_URL);
@@ -12945,15 +13075,17 @@ var LoginCommandHandler = class {
     });
     try {
       const token = await callback.waitForToken;
-      const loginResponse = await this.fetchSession(token);
-      const sessionPath = this.writeSession(loginResponse);
-      ui.success(`Logged in. Session saved to ${sessionPath}`);
+      const loginResponse = await this.fetchSession(token, appId);
+      const saved = saveLoginSession(loginResponse, appId);
+      ui.success(`Logged in to ${saved.app}. Session saved to ${saved.sessionPath}`);
     } finally {
       await callback.close();
     }
   }
-  async fetchSession(token) {
-    const response = await fetch(`${AUTH_API_BASE_URL}/session`, {
+  async fetchSession(token, appId) {
+    const url = new URL(`${AUTH_API_BASE_URL}/session`);
+    url.searchParams.set("app", appId);
+    const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
         Authorization: `Bearer ${token}`
@@ -13071,19 +13203,6 @@ var LoginCommandHandler = class {
       return false;
     }
   }
-  writeSession(session) {
-    const sessionDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate");
-    const sessionPath = import_node_path3.default.join(sessionDir, "session.json");
-    (0, import_node_fs2.mkdirSync)(sessionDir, { recursive: true });
-    (0, import_node_fs2.writeFileSync)(sessionPath, JSON.stringify(session, null, 2), {
-      mode: 384
-    });
-    try {
-      (0, import_node_fs2.chmodSync)(sessionPath, 384);
-    } catch {
-    }
-    return sessionPath;
-  }
 };
 
 // src/services/AliyunService.ts
@@ -13673,10 +13792,8 @@ var AddDnsCommandHandler = class {
 };
 
 // src/commands/StsCommandHandler.ts
-var import_node_fs4 = require("fs");
-var import_node_os3 = __toESM(require("os"));
-var import_node_path5 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
+init_sessionStore();
 var StsCommandHandler = class {
   async handle(_args) {
     const session = this.readSession();
@@ -13704,12 +13821,9 @@ var StsCommandHandler = class {
     ui.plain(import_chalk2.default.cyan(JSON.stringify(payload, null, 2)));
   }
   readSession() {
-    const sessionPath = import_node_path5.default.join(import_node_os3.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs4.existsSync)(sessionPath)) {
-      throw new Error("Missing session. Run `pmate login` first.");
-    }
-    const raw = (0, import_node_fs4.readFileSync)(sessionPath, "utf8");
-    return JSON.parse(raw);
+    return readRequiredSession({
+      preferredApp: DEFAULT_APP_ID
+    });
   }
 };
 
@@ -13723,12 +13837,12 @@ var BucketCommandHandler = class {
 };
 
 // src/commands/DeployCommandHandler.ts
-var import_node_fs5 = require("fs");
-var import_node_path7 = __toESM(require("path"));
+var import_node_fs4 = require("fs");
+var import_node_path6 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 
 // src/appDir.ts
-var import_node_path6 = __toESM(require("path"));
+var import_node_path5 = __toESM(require("path"));
 function normalizeRelativeDir(input, appName) {
   if (typeof input !== "string") {
     throw new Error(`Missing dir for ${appName} in .pmate.yaml`);
@@ -13741,7 +13855,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_path5.default.posix.normalize(unixLike);
   if (normalized.startsWith("../") || normalized === "..") {
     throw new Error(
       `Invalid dir for ${appName} in .pmate.yaml: must stay within repo`
@@ -13751,7 +13865,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_path5.default.resolve(repoRoot, relative);
 }
 function resolveRemoteAppDir(appName, dir) {
   return normalizeRelativeDir(dir, appName);
@@ -13823,8 +13937,8 @@ var DeployCommandHandler = class {
   }
   async deployVite(appName, cwd, appConfig) {
     const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-    const packageJsonPath = import_node_path7.default.join(appDir, "package.json");
-    if (!(0, import_node_fs5.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path6.default.join(appDir, "package.json");
+    if (!(0, import_node_fs4.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -13833,28 +13947,28 @@ var DeployCommandHandler = class {
       throw new Error(`Missing package name in ${packageJsonPath}`);
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], cwd);
-    const distDir = import_node_path7.default.join(appDir, "dist");
-    if (!(0, import_node_fs5.existsSync)(distDir)) {
+    const distDir = import_node_path6.default.join(appDir, "dist");
+    if (!(0, import_node_fs4.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const bucketName = appConfig.bucket?.trim();
     if (!bucketName) {
       throw new Error(
-        `Missing bucket for ${appName} in ${import_node_path7.default.join(cwd, ".pmate.yaml")}`
+        `Missing bucket for ${appName} in ${import_node_path6.default.join(cwd, ".pmate.yaml")}`
       );
     }
     await AliyunService.uploadDirectory(distDir, bucketName);
   }
   async deployStatic(appName, cwd, appConfig) {
     const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-    const srcDir = import_node_path7.default.join(appDir, "src");
-    if (!(0, import_node_fs5.existsSync)(srcDir)) {
+    const srcDir = import_node_path6.default.join(appDir, "src");
+    if (!(0, import_node_fs4.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const bucketName = appConfig.bucket?.trim();
     if (!bucketName) {
       throw new Error(
-        `Missing bucket for ${appName} in ${import_node_path7.default.join(cwd, ".pmate.yaml")}`
+        `Missing bucket for ${appName} in ${import_node_path6.default.join(cwd, ".pmate.yaml")}`
       );
     }
     await AliyunService.uploadDirectory(srcDir, bucketName);
@@ -13960,10 +14074,10 @@ var DeployCommandHandler = class {
     await this.runRemoteCommand(server, command);
   }
   resolveCwd(target) {
-    return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
+    return target ? import_node_path6.default.resolve(process.cwd(), target) : process.cwd();
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs5.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs4.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -14041,7 +14155,7 @@ var DeployCommandHandler = class {
 };
 
 // src/commands/LogCommandHandler.ts
-var import_node_path8 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 var LogCommandHandler = class {
   async handle(args) {
     const appName = args.logApp.trim();
@@ -14065,7 +14179,7 @@ var LogCommandHandler = class {
     this.renderPage(page);
   }
   resolveCwd(target) {
-    return target ? import_node_path8.default.resolve(process.cwd(), target) : process.cwd();
+    return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
   }
   loadClosestConfig(cwd) {
     const loaded = loadAppConfig(cwd, { searchParents: true });
@@ -14112,8 +14226,8 @@ var LogCommandHandler = class {
 };
 
 // src/commands/InitCommandHandler.ts
-var import_node_fs6 = require("fs");
-var import_node_path9 = __toESM(require("path"));
+var import_node_fs5 = require("fs");
+var import_node_path8 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
 var import_promises2 = require("readline/promises");
 var import_yaml2 = __toESM(require("yaml"));
@@ -14151,7 +14265,7 @@ var InitCommandHandler = class {
     }
     if (appConfig.type !== "rust") {
       const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-      if (!(0, import_node_fs6.existsSync)(appDir)) {
+      if (!(0, import_node_fs5.existsSync)(appDir)) {
         throw new Error(`No app folder found at ${appDir}`);
       }
     }
@@ -14180,12 +14294,12 @@ var InitCommandHandler = class {
     const bucketName = appConfig.bucket?.trim();
     if (!bucketName) {
       throw new Error(
-        `Missing bucket for ${appName} in ${import_node_path9.default.join(cwd, ".pmate.yaml")}`
+        `Missing bucket for ${appName} in ${import_node_path8.default.join(cwd, ".pmate.yaml")}`
       );
     }
     const baseDomain = config.domain?.trim();
     if (!baseDomain) {
-      throw new Error(`Missing domain in ${import_node_path9.default.join(cwd, ".pmate.yaml")}`);
+      throw new Error(`Missing domain in ${import_node_path8.default.join(cwd, ".pmate.yaml")}`);
     }
     const subdomain = appConfig.subdomain?.trim();
     const dnsRr = subdomain || "@";
@@ -14319,7 +14433,7 @@ var InitCommandHandler = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = serviceType === "ws" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs6.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs5.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.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`;
@@ -14352,15 +14466,15 @@ var InitCommandHandler = class {
     if (options.ensurePackageJson) {
       const appDir = resolveLocalAppDir(cwd, appConfig.app, appConfig.dir);
       ui.info(`Resolved appDir: ${appDir}`);
-      if (!(0, import_node_fs6.existsSync)(appDir)) {
+      if (!(0, import_node_fs5.existsSync)(appDir)) {
         throw new Error(`Missing app folder at ${appDir}`);
       }
-      const packageJsonPath = import_node_path9.default.join(appDir, "package.json");
+      const packageJsonPath = import_node_path8.default.join(appDir, "package.json");
       ui.info(`Resolved package.json: ${packageJsonPath}`);
-      if (!(0, import_node_fs6.existsSync)(packageJsonPath)) {
+      if (!(0, import_node_fs5.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs6.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs5.statSync)(packageJsonPath);
       ui.info(
         `package.json stat: isFile=${pkgStat.isFile()} isDirectory=${pkgStat.isDirectory()}`
       );
@@ -14380,12 +14494,12 @@ var InitCommandHandler = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path9.default.join(__dirname, "templates", templateName),
-      import_node_path9.default.join(__dirname, "..", "templates", templateName),
-      import_node_path9.default.join(__dirname, "..", "src", "templates", templateName)
+      import_node_path8.default.join(__dirname, "templates", templateName),
+      import_node_path8.default.join(__dirname, "..", "templates", templateName),
+      import_node_path8.default.join(__dirname, "..", "src", "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs6.existsSync)(candidate)) {
+      if ((0, import_node_fs5.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -14433,7 +14547,7 @@ var InitCommandHandler = class {
     });
   }
   resolveCwd(target) {
-    return target ? import_node_path9.default.resolve(process.cwd(), target) : process.cwd();
+    return target ? import_node_path8.default.resolve(process.cwd(), target) : process.cwd();
   }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -14557,7 +14671,7 @@ var InitCommandHandler = class {
     }
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs6.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}`);
@@ -14566,13 +14680,13 @@ var InitCommandHandler = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs6.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs5.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   writeConfig(cwd, config) {
-    const configPath = import_node_path9.default.join(cwd, ".pmate.yaml");
+    const configPath = import_node_path8.default.join(cwd, ".pmate.yaml");
     const serialized = import_yaml2.default.stringify(config).trimEnd();
-    (0, import_node_fs6.writeFileSync)(configPath, `${serialized}
+    (0, import_node_fs5.writeFileSync)(configPath, `${serialized}
 `, "utf8");
   }
   async promptRequired(rl, question) {
@@ -14608,8 +14722,8 @@ var InitCommandHandler = class {
 };
 
 // src/commands/DevCommandHandler.ts
-var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"));
+var import_node_fs6 = require("fs");
+var import_node_path9 = __toESM(require("path"));
 var import_node_child_process4 = require("child_process");
 var DevCommandHandler = class {
   async handle(args) {
@@ -14627,8 +14741,8 @@ var DevCommandHandler = class {
       );
     }
     const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-    const packageJsonPath = import_node_path10.default.join(appDir, "package.json");
-    if (!(0, import_node_fs7.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path9.default.join(appDir, "package.json");
+    if (!(0, import_node_fs6.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -14642,13 +14756,13 @@ var DevCommandHandler = class {
     await this.runCommand("pnpm", ["--filter", pkgName, "run", "dev"], cwd);
   }
   resolveCwd(target) {
-    return target ? import_node_path10.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_fs7.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs6.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -14676,8 +14790,8 @@ var DevCommandHandler = class {
 };
 
 // src/commands/OssCommandHandler.ts
-var import_node_fs8 = require("fs");
-var import_node_path11 = __toESM(require("path"));
+var import_node_fs7 = require("fs");
+var import_node_path10 = __toESM(require("path"));
 var OssCommandHandler = class _OssCommandHandler {
   static {
     this.DEFAULT_BUCKET = "parrot-static";
@@ -14694,17 +14808,17 @@ var OssCommandHandler = class _OssCommandHandler {
       }
       return;
     }
-    const resolvedFile = import_node_path11.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_fs8.existsSync)(filePath)) {
+    if (!(0, import_node_fs7.existsSync)(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const stat = (0, import_node_fs8.statSync)(filePath);
+    const stat = (0, import_node_fs7.statSync)(filePath);
     if (!stat.isFile()) {
       throw new Error(`Not a file: ${filePath}`);
     }
@@ -14726,7 +14840,7 @@ var OssCommandHandler = class _OssCommandHandler {
 };
 
 // src/commands/EnvCommandHandler.ts
-var import_node_path12 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 var import_node_child_process5 = require("child_process");
 var EnvCommandHandler = class {
   async handle(args) {
@@ -14800,8 +14914,8 @@ var EnvCommandHandler = class {
     ui.success(`Set ${envKey} in .env.local`, appName);
   }
   async listEnvKeys(server, repoDir, appDir, verbose) {
-    const envLocalPath = import_node_path12.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path12.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", {
@@ -14894,8 +15008,8 @@ var EnvCommandHandler = class {
     }
   }
   async appendEnvLine(server, repoDir, appDir, envKey, envLine, verbose) {
-    const envLocalPath = import_node_path12.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path12.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", {
@@ -14943,8 +15057,8 @@ var EnvCommandHandler = class {
     await this.runRemoteCommand(server, command);
   }
   async deleteEnvKey(server, repoDir, appDir, envKey, verbose) {
-    const envLocalPath = import_node_path12.default.posix.join(appDir, ".env.local");
-    const envPath = import_node_path12.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", {
@@ -15714,7 +15828,7 @@ var CommitCommandHandler = class {
 
 // src/commands/SummaryCommandHandler.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path14 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var SummaryCommandHandler = class {
   async handle(args) {
     const cwd = this.resolveCwd(args.cwd);
@@ -15899,7 +16013,7 @@ var SummaryCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path14.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
   }
 };
 function truncate2(value, limit) {
@@ -15912,9 +16026,9 @@ function truncate2(value, limit) {
 
 // src/commands/LinearCommandHandler.ts
 var import_node_child_process8 = require("child_process");
-var import_node_fs10 = require("fs");
-var import_node_os5 = __toESM(require("os"));
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs8 = require("fs");
+var import_node_os3 = __toESM(require("os"));
+var import_node_path13 = __toESM(require("path"));
 var import_promises3 = require("readline/promises");
 var import_openai = __toESM(require("openai"));
 var import_sdk = require("@linear/sdk");
@@ -16798,15 +16912,15 @@ var LinearCommandHandler = class {
     }
   }
   getLinearSelectionPath() {
-    return import_node_path15.default.join(import_node_os5.default.homedir(), ".pmate", "linear-selection.json");
+    return import_node_path13.default.join(import_node_os3.default.homedir(), ".pmate", "linear-selection.json");
   }
   readCachedLinearSelection(cwd) {
     const selectionPath = this.getLinearSelectionPath();
-    if (!(0, import_node_fs10.existsSync)(selectionPath)) {
+    if (!(0, import_node_fs8.existsSync)(selectionPath)) {
       return void 0;
     }
     try {
-      const raw = (0, import_node_fs10.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];
@@ -16817,12 +16931,12 @@ var LinearCommandHandler = class {
   }
   writeCachedLinearSelection(cwd, title) {
     const selectionPath = this.getLinearSelectionPath();
-    const dir = import_node_path15.default.dirname(selectionPath);
-    (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+    const dir = import_node_path13.default.dirname(selectionPath);
+    (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
     let data = {};
-    if ((0, import_node_fs10.existsSync)(selectionPath)) {
+    if ((0, import_node_fs8.existsSync)(selectionPath)) {
       try {
-        const raw = (0, import_node_fs10.readFileSync)(selectionPath, "utf8").trim();
+        const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
         if (raw) {
           data = JSON.parse(raw);
         }
@@ -16831,7 +16945,7 @@ var LinearCommandHandler = class {
       }
     }
     data[cwd] = title;
-    (0, import_node_fs10.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
+    (0, import_node_fs8.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   }
   async lookupIssue(client, issueRef) {
@@ -17008,14 +17122,14 @@ var LinearCommandHandler = class {
     if (process.platform !== "darwin") {
       throw new Error("Screenshot capture only supports macOS.");
     }
-    const dir = await import_node_fs10.promises.mkdtemp(import_node_path15.default.join(import_node_os5.default.tmpdir(), "pmate-screenshot-"));
-    const filePath = import_node_path15.default.join(dir, `screenshot-${index}.png`);
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os3.default.tmpdir(), "pmate-screenshot-"));
+    const filePath = import_node_path13.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_fs10.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.");
       }
@@ -17027,7 +17141,7 @@ var LinearCommandHandler = class {
       return { buffer, mime, filename: `screenshot-${index}.${extension}` };
     } finally {
       try {
-        await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -17171,17 +17285,17 @@ var LinearCommandHandler = class {
     return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
   }
   async convertToPng(buffer, ext) {
-    const dir = await import_node_fs10.promises.mkdtemp(import_node_path15.default.join(import_node_os5.default.tmpdir(), "pmate-"));
-    const inputPath = import_node_path15.default.join(dir, `clipboard.${ext}`);
-    const outputPath = import_node_path15.default.join(dir, "clipboard.png");
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os3.default.tmpdir(), "pmate-"));
+    const inputPath = import_node_path13.default.join(dir, `clipboard.${ext}`);
+    const outputPath = import_node_path13.default.join(dir, "clipboard.png");
     try {
-      await import_node_fs10.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_fs10.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.`
@@ -17190,7 +17304,7 @@ var LinearCommandHandler = class {
       return out;
     } finally {
       try {
-        await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -17484,7 +17598,7 @@ var LinearCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path15.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path13.default.resolve(process.cwd(), value) : process.cwd();
   }
   createOpenAiClient() {
     const config = loadPmateConfig();
@@ -17536,8 +17650,8 @@ function sleep(ms) {
 }
 
 // src/commands/NotionCommandHandler.ts
-var import_node_fs11 = require("fs");
-var import_node_path16 = __toESM(require("path"));
+var import_node_fs9 = require("fs");
+var import_node_path14 = __toESM(require("path"));
 
 // src/services/NotionService.ts
 var NotionService = class {
@@ -17776,9 +17890,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path22, init) {
+  static async requestJson(path20, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path22}`, {
+    const response = await fetch(`${this.baseUrl}${path20}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -17876,16 +17990,16 @@ var NotionCommandHandler = class {
     if (!args.filePath) {
       return "";
     }
-    const resolved = import_node_path16.default.resolve(process.cwd(), args.filePath);
-    return (0, import_node_fs11.readFileSync)(resolved, "utf8");
+    const resolved = import_node_path14.default.resolve(process.cwd(), args.filePath);
+    return (0, import_node_fs9.readFileSync)(resolved, "utf8");
   }
 };
 
 // src/commands/QrcodeCommandHandler.ts
 var import_node_child_process9 = require("child_process");
-var import_node_fs12 = require("fs");
-var import_node_os6 = __toESM(require("os"));
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs10 = require("fs");
+var import_node_os4 = __toESM(require("os"));
+var import_node_path15 = __toESM(require("path"));
 var import_promises4 = require("readline/promises");
 var import_jsqr = __toESM(require("jsqr"));
 var import_pngjs = require("pngjs");
@@ -17911,7 +18025,7 @@ var QrcodeCommandHandler = class {
       ui.success("QR code value:", value);
     } finally {
       try {
-        await import_node_fs12.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -17927,13 +18041,13 @@ var QrcodeCommandHandler = class {
     } finally {
       rl.close();
     }
-    const dir = await import_node_fs12.promises.mkdtemp(import_node_path17.default.join(import_node_os6.default.tmpdir(), "pmate-qrcode-"));
-    const filePath = import_node_path17.default.join(dir, "qrcode.png");
+    const dir = await import_node_fs10.promises.mkdtemp(import_node_path15.default.join(import_node_os4.default.tmpdir(), "pmate-qrcode-"));
+    const filePath = import_node_path15.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_fs12.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.");
     }
@@ -17949,7 +18063,7 @@ var QrcodeCommandHandler = class {
   async decodeQr(filePath) {
     let buffer;
     try {
-      buffer = await import_node_fs12.promises.readFile(filePath);
+      buffer = await import_node_fs10.promises.readFile(filePath);
     } catch {
       return null;
     }
@@ -18209,9 +18323,9 @@ function clampNumber(value, min, max, fallback) {
 // src/commands/CollectCommandHandler.ts
 var import_playwright = require("playwright");
 var import_node_crypto3 = require("crypto");
-var import_node_fs13 = require("fs");
-var import_node_os7 = __toESM(require("os"));
-var import_node_path18 = __toESM(require("path"));
+var import_node_fs11 = require("fs");
+var import_node_os5 = __toESM(require("os"));
+var import_node_path16 = __toESM(require("path"));
 var CollectCommandHandler = class {
   async handle(args) {
     let browser = null;
@@ -18578,19 +18692,19 @@ function computeMessageHash(threadName, message) {
   return (0, import_node_crypto3.createHash)("sha1").update(base).digest("hex").slice(0, 16);
 }
 async function toDisplayableImagePath(src) {
-  if (!import_node_path18.default.isAbsolute(src)) {
+  if (!import_node_path16.default.isAbsolute(src)) {
     return src;
   }
-  const ext = import_node_path18.default.extname(src);
+  const ext = import_node_path16.default.extname(src);
   if (ext) {
     return src;
   }
   try {
-    const stat = await import_node_fs13.promises.stat(src);
+    const stat = await import_node_fs11.promises.stat(src);
     if (!stat.isFile()) {
       return src;
     }
-    const fh = await import_node_fs13.promises.open(src, "r");
+    const fh = await import_node_fs11.promises.open(src, "r");
     try {
       const buf = Buffer.alloc(32);
       const { bytesRead } = await fh.read(buf, 0, 32, 0);
@@ -18599,17 +18713,17 @@ async function toDisplayableImagePath(src) {
       if (!guessedExt) {
         return src;
       }
-      const cacheDir = import_node_path18.default.join(
-        import_node_os7.default.homedir(),
+      const cacheDir = import_node_path16.default.join(
+        import_node_os5.default.homedir(),
         ".pmate",
         "messages",
         "images"
       );
-      await import_node_fs13.promises.mkdir(cacheDir, { recursive: true });
+      await import_node_fs11.promises.mkdir(cacheDir, { recursive: true });
       const base = (0, import_node_crypto3.createHash)("sha1").update(src).digest("hex");
-      const displayPath = import_node_path18.default.join(cacheDir, `${base}.${guessedExt}`);
-      await import_node_fs13.promises.rm(displayPath, { force: true }).catch(() => void 0);
-      await import_node_fs13.promises.copyFile(src, displayPath);
+      const displayPath = import_node_path16.default.join(cacheDir, `${base}.${guessedExt}`);
+      await import_node_fs11.promises.rm(displayPath, { force: true }).catch(() => void 0);
+      await import_node_fs11.promises.copyFile(src, displayPath);
       return displayPath;
     } finally {
       await fh.close();
@@ -18665,9 +18779,9 @@ function parseMessageText(raw) {
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs14 = require("fs");
-var import_node_os8 = __toESM(require("os"));
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs12 = require("fs");
+var import_node_path17 = __toESM(require("path"));
+init_sessionStore();
 var AgentCommandHandler = class {
   async handle(args) {
     const token = this.readToken();
@@ -18749,24 +18863,16 @@ var AgentCommandHandler = class {
     );
   }
   readToken() {
-    const sessionPath = import_node_path19.default.join(import_node_os8.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs14.existsSync)(sessionPath)) {
-      throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
-    }
-    const raw = (0, import_node_fs14.readFileSync)(sessionPath, "utf8");
-    const parsed = JSON.parse(raw);
-    const token = parsed.token?.trim();
-    if (!token) {
-      throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
-    }
-    return token;
+    return readRequiredSession({
+      preferredApp: DEFAULT_APP_ID
+    }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18835,9 +18941,9 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs15 = require("fs");
-var import_node_os9 = __toESM(require("os"));
-var import_node_path20 = __toESM(require("path"));
+var import_node_fs13 = require("fs");
+var import_node_path18 = __toESM(require("path"));
+init_sessionStore();
 var AppCommandHandler = class {
   async handle(args) {
     const token = this.readToken();
@@ -18906,24 +19012,16 @@ var AppCommandHandler = class {
     return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
   }
   readToken() {
-    const sessionPath = import_node_path20.default.join(import_node_os9.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs15.existsSync)(sessionPath)) {
-      throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
-    }
-    const raw = (0, import_node_fs15.readFileSync)(sessionPath, "utf8");
-    const parsed = JSON.parse(raw);
-    const token = parsed.token?.trim();
-    if (!token) {
-      throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
-    }
-    return token;
+    return readRequiredSession({
+      preferredApp: DEFAULT_APP_ID
+    }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19340,7 +19438,7 @@ function requireValue2(tokens, optionName) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs16.readFileSync)(import_node_path21.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs14.readFileSync)(import_node_path19.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk3.default.bold(`pmate v${pkg.version}`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {