@pmate/cli 0.13.0 → 0.13.1

package/dist/index.js

@@ -12407,10 +12407,10 @@ function resolveHubBaseUrl(value) {
 }
 function readSessionToken() {
   const sessionPath = import_node_path13.default.join(import_node_os4.default.homedir(), ".pmate", "session.json");
-  if (!(0, import_node_fs12.existsSync)(sessionPath)) {
+  if (!(0, import_node_fs10.existsSync)(sessionPath)) {
     throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
   }
-  const raw = (0, import_node_fs12.readFileSync)(sessionPath, "utf8");
+  const raw = (0, import_node_fs10.readFileSync)(sessionPath, "utf8");
   const parsed = JSON.parse(raw);
   const token = parsed.token?.trim();
   if (!token) {
@@ -12427,11 +12427,11 @@ function unwrapAgentResult(value) {
   }
   return value;
 }
-var import_node_fs12, 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_node_fs10, 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 init_AgentLlmClient = __esm({
   "src/llm/AgentLlmClient.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs10 = require("fs");
     import_node_os4 = __toESM(require("os"));
     import_node_path13 = __toESM(require("path"));
     import_agent_sdk = __toESM(require_dist4());
@@ -12479,7 +12479,7 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs19 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_path21 = __toESM(require("path"));
 var import_chalk3 = __toESM(require("chalk"));
 
@@ -12523,235 +12523,14 @@ var ui = {
 };
 
 // src/commands/ListCommandHandler.ts
-var import_node_fs = require("fs");
-var import_node_path = __toESM(require("path"));
-var import_yaml = __toESM(require("yaml"));
-var ListCommandHandler = class {
-  handle(args) {
-    const targetDir = this.resolveTargetDir(args.targetPath);
-    const config = this.loadConfig(targetDir);
-    if (config.apps.length === 0) {
-      ui.warn("No apps defined.");
-      return;
-    }
-    for (const app of config.apps) {
-      if (app && typeof app.app === "string") {
-        if (typeof app.dir !== "string" || !app.dir.trim()) {
-          throw new Error(`Invalid .pmate.yaml: missing dir for app ${app.app}`);
-        }
-        ui.info(`${app.app} -> ${app.dir}`);
-      }
-    }
-  }
-  resolveTargetDir(targetPath) {
-    return targetPath ? import_node_path.default.resolve(process.cwd(), targetPath) : process.cwd();
-  }
-  loadConfig(targetDir) {
-    const configPath = import_node_path.default.join(targetDir, ".pmate.yaml");
-    if (!(0, import_node_fs.existsSync)(configPath)) {
-      throw new Error(`No .pmate.yaml found in ${targetDir}`);
-    }
-    const raw = (0, import_node_fs.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error("Invalid .pmate.yaml: missing apps array");
-    }
-    return parsed;
-  }
-};
-
-// src/commands/LoginCommandHandler.ts
-var import_node_fs2 = require("fs");
-var import_node_http = require("http");
-var import_node_os = __toESM(require("os"));
 var import_node_path2 = __toESM(require("path"));
-var import_node_child_process = require("child_process");
-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);
-  url.searchParams.set("redirect", redirectUrl);
-  url.searchParams.set("app", appId);
-  return url.toString();
-}
-var LoginCommandHandler = class {
-  async handle(args) {
-    const callback = await this.startCallbackServer();
-    const appId = args.app?.trim() || DEFAULT_APP_ID;
-    const loginUrl = buildHostedLoginUrl(callback.redirectUrl, appId);
-    ui.info("Opening browser for login.", {
-      url: loginUrl,
-      app: appId
-    });
-    if (!this.openBrowser(loginUrl)) {
-      ui.warn("Unable to open the browser automatically.");
-      ui.plain(loginUrl);
-    }
-    ui.info("Waiting for login redirect...", {
-      callback: callback.redirectUrl,
-      app: appId
-    });
-    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}`);
-    } finally {
-      await callback.close();
-    }
-  }
-  async fetchSession(token) {
-    const response = await fetch(`${AUTH_API_BASE_URL}/session`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const detail = await response.text();
-      throw new Error(
-        `Failed to validate session (${response.status}): ${detail || response.statusText}`
-      );
-    }
-    const resp = await response.json();
-    return {
-      ...resp.data,
-      token
-    };
-  }
-  async startCallbackServer() {
-    let resolveToken;
-    let rejectToken;
-    const waitForToken = new Promise((resolve, reject) => {
-      resolveToken = resolve;
-      rejectToken = reject;
-    });
-    const server = (0, import_node_http.createServer)((request, response) => {
-      this.handleCallbackRequest(request, response, resolveToken, rejectToken);
-    });
-    await new Promise((resolve, reject) => {
-      server.once("error", reject);
-      server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    if (!address || typeof address === "string") {
-      server.close();
-      throw new Error("Failed to start login callback server.");
-    }
-    const redirectUrl = `http://127.0.0.1:${address.port}${CALLBACK_PATH}`;
-    const timeout = setTimeout(() => {
-      rejectToken(
-        new Error(
-          `Timed out waiting for browser login after ${LOGIN_TIMEOUT_MS / 1e3} seconds.`
-        )
-      );
-    }, LOGIN_TIMEOUT_MS);
-    const close = async () => {
-      clearTimeout(timeout);
-      await new Promise((resolve) => {
-        server.close(() => resolve());
-      });
-    };
-    return {
-      redirectUrl,
-      waitForToken,
-      close
-    };
-  }
-  handleCallbackRequest(request, response, resolveToken, rejectToken) {
-    const url = new URL(request.url || "/", "http://127.0.0.1");
-    if (url.pathname !== CALLBACK_PATH) {
-      response.statusCode = 404;
-      response.end("Not found");
-      return;
-    }
-    const token = url.searchParams.get("sessionId")?.trim();
-    if (!token) {
-      response.statusCode = 400;
-      response.setHeader("Content-Type", "text/html; charset=utf-8");
-      response.end(this.renderHtml("Login failed", "Missing sessionId in redirect URL."));
-      rejectToken(new Error("Login callback did not include sessionId."));
-      return;
-    }
-    response.statusCode = 200;
-    response.setHeader("Content-Type", "text/html; charset=utf-8");
-    response.end(
-      this.renderHtml(
-        "Login complete",
-        "You can close this tab and return to the terminal."
-      )
-    );
-    resolveToken(token);
-  }
-  renderHtml(title, message) {
-    return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${title}</title>
-    <style>
-      body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 32px; color: #111; }
-      main { max-width: 560px; margin: 10vh auto; }
-      h1 { font-size: 28px; margin-bottom: 12px; }
-      p { font-size: 16px; line-height: 1.5; }
-    </style>
-  </head>
-  <body>
-    <main>
-      <h1>${title}</h1>
-      <p>${message}</p>
-    </main>
-  </body>
-</html>`;
-  }
-  openBrowser(url) {
-    const platform = process.platform;
-    const command = platform === "darwin" ? { cmd: "open", args: [url] } : platform === "win32" ? { cmd: "cmd", args: ["/c", "start", "", url] } : { cmd: "xdg-open", args: [url] };
-    try {
-      const child = (0, import_node_child_process.spawn)(command.cmd, command.args, {
-        detached: true,
-        stdio: "ignore"
-      });
-      child.unref();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  writeSession(session) {
-    const sessionDir = import_node_path2.default.join(import_node_os.default.homedir(), ".pmate");
-    const sessionPath = import_node_path2.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
-var import_alidns20150109 = __toESM(require("@alicloud/alidns20150109"));
-var import_cdn20180510 = __toESM(require("@alicloud/cdn20180510"));
-var import_openapi_client = require("@alicloud/openapi-client");
-var import_ali_oss = __toESM(require("ali-oss"));
-var import_node_crypto = require("crypto");
-var import_node_fs4 = require("fs");
-var import_node_path4 = __toESM(require("path"));
 
 // src/config.ts
-var import_node_fs3 = require("fs");
-var import_node_os2 = __toESM(require("os"));
-var import_node_path3 = __toESM(require("path"));
+var import_node_fs = require("fs");
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
 var import_ajv = __toESM(require("ajv"));
-var import_yaml2 = __toESM(require("yaml"));
+var import_yaml = __toESM(require("yaml"));
 var cachedConfig;
 var CONFIG = new Proxy({}, {
   get(_target, prop) {
@@ -12873,13 +12652,13 @@ function loadPmateConfig() {
   if (cachedConfig !== void 0) {
     return cachedConfig ?? {};
   }
-  const pmateDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate");
-  const yamlPath = import_node_path3.default.join(pmateDir, "config.yaml");
+  const pmateDir = import_node_path.default.join(import_node_os.default.homedir(), ".pmate");
+  const yamlPath = import_node_path.default.join(pmateDir, "config.yaml");
   let yamlConfig = null;
-  if ((0, import_node_fs3.existsSync)(yamlPath)) {
-    const raw = (0, import_node_fs3.readFileSync)(yamlPath, "utf8");
+  if ((0, import_node_fs.existsSync)(yamlPath)) {
+    const raw = (0, import_node_fs.readFileSync)(yamlPath, "utf8");
     try {
-      const parsed = import_yaml2.default.parse(raw);
+      const parsed = import_yaml.default.parse(raw);
       yamlConfig = validateParsedConfig(parsed, yamlPath);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -12890,19 +12669,38 @@ function loadPmateConfig() {
   return cachedConfig;
 }
 function loadRepoConfig(cwd) {
-  const configPath = findRepoConfigPath(cwd);
-  if (!configPath) {
+  const paths = findRepoConfigPaths(cwd, true);
+  if (!paths) {
     return null;
   }
-  const raw = (0, import_node_fs3.readFileSync)(configPath, "utf8");
-  let parsed;
-  try {
-    parsed = import_yaml2.default.parse(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Invalid YAML in ${configPath}: ${message}`);
+  const parsed = loadMergedRepoYaml(paths);
+  return normalizeRepoConfig(parsed, paths.configPath);
+}
+function loadAppConfig(cwd, options = {}) {
+  const paths = findRepoConfigPaths(cwd, options.searchParents ?? false);
+  if (!paths) {
+    const suffix = options.searchParents ? " or parent directories" : "";
+    throw new Error(`No .pmate.yaml found in ${cwd}${suffix}`);
+  }
+  const parsed = loadMergedRepoYaml(paths);
+  const appConfig = parsed;
+  if (!appConfig || typeof appConfig !== "object" || !Array.isArray(appConfig.apps)) {
+    throw new Error(
+      `Invalid .pmate.yaml: missing apps array (${describeRepoConfigPaths(paths)})`
+    );
   }
-  return normalizeRepoConfig(parsed, configPath);
+  return {
+    config: appConfig,
+    rootDir: paths.rootDir,
+    configPath: paths.configPath,
+    localConfigPath: paths.localConfigPath
+  };
+}
+function describeLoadedAppConfig({
+  configPath,
+  localConfigPath
+}) {
+  return localConfigPath ? `${configPath} + ${localConfigPath}` : configPath;
 }
 function validateParsedConfig(value, configPath) {
   if (value === null || value === void 0) {
@@ -12918,101 +12716,384 @@ ${detail}`);
   }
   return value;
 }
-function findRepoConfigPath(cwd) {
-  let current = import_node_path3.default.resolve(cwd);
+function findRepoConfigPaths(cwd, searchParents) {
+  let current = import_node_path.default.resolve(cwd);
   while (true) {
-    const candidate = import_node_path3.default.join(current, ".pmate.yaml");
-    if ((0, import_node_fs3.existsSync)(candidate)) {
-      return candidate;
+    const candidate = import_node_path.default.join(current, ".pmate.yaml");
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      const localCandidate = import_node_path.default.join(current, ".pmate.local.yaml");
+      return {
+        rootDir: current,
+        configPath: candidate,
+        localConfigPath: (0, import_node_fs.existsSync)(localCandidate) ? localCandidate : void 0
+      };
+    }
+    if (!searchParents) {
+      return null;
     }
-    const parent = import_node_path3.default.dirname(current);
+    const parent = import_node_path.default.dirname(current);
     if (parent === current) {
       return null;
     }
-    current = parent;
-  }
-}
-function normalizeRepoConfig(value, configPath) {
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  const config = value;
-  const hasRepoKeys = "githubUser" in config || "linear" in config;
-  if (!hasRepoKeys) {
-    return null;
+    current = parent;
+  }
+}
+function loadMergedRepoYaml(paths) {
+  const base = parseYamlFile(paths.configPath);
+  if (!paths.localConfigPath) {
+    return base;
+  }
+  const local = parseYamlFile(paths.localConfigPath);
+  return mergeRepoConfigValues(base, local);
+}
+function parseYamlFile(configPath) {
+  const raw = (0, import_node_fs.readFileSync)(configPath, "utf8");
+  try {
+    return import_yaml.default.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid YAML in ${configPath}: ${message}`);
+  }
+}
+function describeRepoConfigPaths(paths) {
+  return paths.localConfigPath ? `${paths.configPath} + ${paths.localConfigPath}` : paths.configPath;
+}
+function mergeRepoConfigValues(base, local) {
+  if (Array.isArray(base) && Array.isArray(local)) {
+    return [...base, ...local];
+  }
+  if (isPlainObject(base) && isPlainObject(local)) {
+    const merged = { ...base };
+    for (const [key, localValue] of Object.entries(local)) {
+      const baseValue = merged[key];
+      if (key === "apps" && Array.isArray(baseValue) && Array.isArray(localValue)) {
+        merged[key] = mergeApps(baseValue, localValue);
+        continue;
+      }
+      merged[key] = mergeRepoConfigValues(baseValue, localValue);
+    }
+    return merged;
+  }
+  return local === void 0 ? base : local;
+}
+function mergeApps(baseApps, localApps) {
+  const merged = [...baseApps];
+  for (const localApp of localApps) {
+    const localName = getAppName(localApp);
+    if (!localName) {
+      merged.push(localApp);
+      continue;
+    }
+    const baseIndex = merged.findIndex((entry) => getAppName(entry) === localName);
+    if (baseIndex === -1) {
+      merged.push(localApp);
+      continue;
+    }
+    merged[baseIndex] = mergeRepoConfigValues(merged[baseIndex], localApp);
+  }
+  return merged;
+}
+function getAppName(value) {
+  if (!isPlainObject(value) || typeof value.app !== "string") {
+    return void 0;
+  }
+  const app = value.app.trim();
+  return app || void 0;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeRepoConfig(value, configPath) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const config = value;
+  const hasRepoKeys = "githubUser" in config || "linear" in config;
+  if (!hasRepoKeys) {
+    return null;
+  }
+  const repoConfig = {};
+  if (config.githubUser !== void 0) {
+    if (typeof config.githubUser !== "string" || !config.githubUser.trim()) {
+      throw new Error(
+        `Invalid repo config in ${configPath}: githubUser must be a non-empty string.`
+      );
+    }
+    repoConfig.githubUser = config.githubUser.trim();
+  }
+  if (config.linear !== void 0) {
+    if (!config.linear || typeof config.linear !== "object") {
+      throw new Error(
+        `Invalid repo config in ${configPath}: linear must be an object.`
+      );
+    }
+    const linear = config.linear;
+    const teamId = getOptionalString(linear.teamId);
+    const teamKey = getOptionalString(linear.teamKey);
+    const rawAccount = linear.account ?? linear.accounts;
+    if (!rawAccount) {
+      throw new Error(
+        `Invalid repo config in ${configPath}: linear account is required.`
+      );
+    }
+    const account = normalizeRepoLinearAccount(rawAccount, configPath);
+    repoConfig.linear = {
+      teamId,
+      teamKey,
+      account
+    };
+  }
+  return repoConfig;
+}
+function normalizeRepoLinearAccount(value, configPath) {
+  const account = Array.isArray(value) ? value : [value];
+  if (account.length !== 1) {
+    throw new Error(
+      `Invalid repo config in ${configPath}: linear account must be a single entry.`
+    );
+  }
+  const entry = account[0];
+  if (!entry || typeof entry !== "object") {
+    throw new Error(
+      `Invalid repo config in ${configPath}: linear account must be an object.`
+    );
+  }
+  const raw = entry;
+  const apiKey = getOptionalString(raw.apiKey);
+  if (!apiKey) {
+    throw new Error(
+      `Invalid repo config in ${configPath}: linear account apiKey is required.`
+    );
+  }
+  const title = getOptionalString(raw.title) || "Repo";
+  const teamId = getOptionalString(raw.teamId);
+  const teamKey = getOptionalString(raw.teamKey);
+  return {
+    title,
+    apiKey,
+    teamId,
+    teamKey
+  };
+}
+function getOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+
+// src/commands/ListCommandHandler.ts
+var ListCommandHandler = class {
+  handle(args) {
+    const targetDir = this.resolveTargetDir(args.targetPath);
+    const config = this.loadConfig(targetDir);
+    if (config.apps.length === 0) {
+      ui.warn("No apps defined.");
+      return;
+    }
+    for (const app of config.apps) {
+      if (app && typeof app.app === "string") {
+        if (typeof app.dir !== "string" || !app.dir.trim()) {
+          throw new Error(`Invalid .pmate.yaml: missing dir for app ${app.app}`);
+        }
+        ui.info(`${app.app} -> ${app.dir}`);
+      }
+    }
+  }
+  resolveTargetDir(targetPath) {
+    return targetPath ? import_node_path2.default.resolve(process.cwd(), targetPath) : process.cwd();
+  }
+  loadConfig(targetDir) {
+    return loadAppConfig(targetDir).config;
+  }
+};
+
+// 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");
+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);
+  url.searchParams.set("redirect", redirectUrl);
+  url.searchParams.set("app", appId);
+  return url.toString();
+}
+var LoginCommandHandler = class {
+  async handle(args) {
+    const callback = await this.startCallbackServer();
+    const appId = args.app?.trim() || DEFAULT_APP_ID;
+    const loginUrl = buildHostedLoginUrl(callback.redirectUrl, appId);
+    ui.info("Opening browser for login.", {
+      url: loginUrl,
+      app: appId
+    });
+    if (!this.openBrowser(loginUrl)) {
+      ui.warn("Unable to open the browser automatically.");
+      ui.plain(loginUrl);
+    }
+    ui.info("Waiting for login redirect...", {
+      callback: callback.redirectUrl,
+      app: appId
+    });
+    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}`);
+    } finally {
+      await callback.close();
+    }
   }
-  const repoConfig = {};
-  if (config.githubUser !== void 0) {
-    if (typeof config.githubUser !== "string" || !config.githubUser.trim()) {
+  async fetchSession(token) {
+    const response = await fetch(`${AUTH_API_BASE_URL}/session`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      const detail = await response.text();
       throw new Error(
-        `Invalid repo config in ${configPath}: githubUser must be a non-empty string.`
+        `Failed to validate session (${response.status}): ${detail || response.statusText}`
       );
     }
-    repoConfig.githubUser = config.githubUser.trim();
+    const resp = await response.json();
+    return {
+      ...resp.data,
+      token
+    };
   }
-  if (config.linear !== void 0) {
-    if (!config.linear || typeof config.linear !== "object") {
-      throw new Error(
-        `Invalid repo config in ${configPath}: linear must be an object.`
-      );
+  async startCallbackServer() {
+    let resolveToken;
+    let rejectToken;
+    const waitForToken = new Promise((resolve, reject) => {
+      resolveToken = resolve;
+      rejectToken = reject;
+    });
+    const server = (0, import_node_http.createServer)((request, response) => {
+      this.handleCallbackRequest(request, response, resolveToken, rejectToken);
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      server.close();
+      throw new Error("Failed to start login callback server.");
     }
-    const linear = config.linear;
-    const teamId = getOptionalString(linear.teamId);
-    const teamKey = getOptionalString(linear.teamKey);
-    const rawAccount = linear.account ?? linear.accounts;
-    if (!rawAccount) {
-      throw new Error(
-        `Invalid repo config in ${configPath}: linear account is required.`
+    const redirectUrl = `http://127.0.0.1:${address.port}${CALLBACK_PATH}`;
+    const timeout = setTimeout(() => {
+      rejectToken(
+        new Error(
+          `Timed out waiting for browser login after ${LOGIN_TIMEOUT_MS / 1e3} seconds.`
+        )
       );
-    }
-    const account = normalizeRepoLinearAccount(rawAccount, configPath);
-    repoConfig.linear = {
-      teamId,
-      teamKey,
-      account
+    }, LOGIN_TIMEOUT_MS);
+    const close = async () => {
+      clearTimeout(timeout);
+      await new Promise((resolve) => {
+        server.close(() => resolve());
+      });
+    };
+    return {
+      redirectUrl,
+      waitForToken,
+      close
     };
   }
-  return repoConfig;
-}
-function normalizeRepoLinearAccount(value, configPath) {
-  const account = Array.isArray(value) ? value : [value];
-  if (account.length !== 1) {
-    throw new Error(
-      `Invalid repo config in ${configPath}: linear account must be a single entry.`
+  handleCallbackRequest(request, response, resolveToken, rejectToken) {
+    const url = new URL(request.url || "/", "http://127.0.0.1");
+    if (url.pathname !== CALLBACK_PATH) {
+      response.statusCode = 404;
+      response.end("Not found");
+      return;
+    }
+    const token = url.searchParams.get("sessionId")?.trim();
+    if (!token) {
+      response.statusCode = 400;
+      response.setHeader("Content-Type", "text/html; charset=utf-8");
+      response.end(this.renderHtml("Login failed", "Missing sessionId in redirect URL."));
+      rejectToken(new Error("Login callback did not include sessionId."));
+      return;
+    }
+    response.statusCode = 200;
+    response.setHeader("Content-Type", "text/html; charset=utf-8");
+    response.end(
+      this.renderHtml(
+        "Login complete",
+        "You can close this tab and return to the terminal."
+      )
     );
+    resolveToken(token);
   }
-  const entry = account[0];
-  if (!entry || typeof entry !== "object") {
-    throw new Error(
-      `Invalid repo config in ${configPath}: linear account must be an object.`
-    );
+  renderHtml(title, message) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title}</title>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 32px; color: #111; }
+      main { max-width: 560px; margin: 10vh auto; }
+      h1 { font-size: 28px; margin-bottom: 12px; }
+      p { font-size: 16px; line-height: 1.5; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${title}</h1>
+      <p>${message}</p>
+    </main>
+  </body>
+</html>`;
   }
-  const raw = entry;
-  const apiKey = getOptionalString(raw.apiKey);
-  if (!apiKey) {
-    throw new Error(
-      `Invalid repo config in ${configPath}: linear account apiKey is required.`
-    );
+  openBrowser(url) {
+    const platform = process.platform;
+    const command = platform === "darwin" ? { cmd: "open", args: [url] } : platform === "win32" ? { cmd: "cmd", args: ["/c", "start", "", url] } : { cmd: "xdg-open", args: [url] };
+    try {
+      const child = (0, import_node_child_process.spawn)(command.cmd, command.args, {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return true;
+    } catch {
+      return false;
+    }
   }
-  const title = getOptionalString(raw.title) || "Repo";
-  const teamId = getOptionalString(raw.teamId);
-  const teamKey = getOptionalString(raw.teamKey);
-  return {
-    title,
-    apiKey,
-    teamId,
-    teamKey
-  };
-}
-function getOptionalString(value) {
-  if (typeof value !== "string") {
-    return void 0;
+  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;
   }
-  const trimmed = value.trim();
-  return trimmed ? trimmed : void 0;
-}
+};
 
 // src/services/AliyunService.ts
+var import_alidns20150109 = __toESM(require("@alicloud/alidns20150109"));
+var import_cdn20180510 = __toESM(require("@alicloud/cdn20180510"));
+var import_openapi_client = require("@alicloud/openapi-client");
+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 AliyunService = class {
   /** Add a DNS record via Aliyun DNS. */
   static async addRecord(input) {
@@ -13155,7 +13236,7 @@ var AliyunService = class {
       const options = contentType ? { headers: { "Content-Type": contentType } } : void 0;
       const existing = existingMap.get(objectKey);
       if (existing && typeof existing.size === "number") {
-        const stat = await import_node_fs4.promises.stat(filePath);
+        const stat = await import_node_fs3.promises.stat(filePath);
         if (stat.size === existing.size) {
           const etag = this.normalizeEtag(existing.etag);
           if (etag && !etag.includes("-")) {
@@ -13180,7 +13261,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_fs4.existsSync)(localFile)) {
+    if (!(0, import_node_fs3.existsSync)(localFile)) {
       throw new Error(`File not found: ${localFile}`);
     }
     const client = new import_ali_oss.default({ region, accessKeyId, accessKeySecret, bucket });
@@ -13455,7 +13536,7 @@ var AliyunService = class {
   }
   /** Recursively collect file paths under a directory. */
   static async collectFiles(dir) {
-    const entries = await import_node_fs4.promises.readdir(dir, { withFileTypes: true });
+    const entries = await import_node_fs3.promises.readdir(dir, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
       const fullPath = import_node_path4.default.join(dir, entry.name);
@@ -13507,7 +13588,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_fs4.createReadStream)(filePath);
+      const stream = (0, import_node_fs3.createReadStream)(filePath);
       stream.on("data", (chunk) => {
         hash.update(chunk);
       });
@@ -13592,7 +13673,7 @@ var AddDnsCommandHandler = class {
 };
 
 // src/commands/StsCommandHandler.ts
-var import_node_fs5 = require("fs");
+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"));
@@ -13624,10 +13705,10 @@ var StsCommandHandler = class {
   }
   readSession() {
     const sessionPath = import_node_path5.default.join(import_node_os3.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs5.existsSync)(sessionPath)) {
+    if (!(0, import_node_fs4.existsSync)(sessionPath)) {
       throw new Error("Missing session. Run `pmate login` first.");
     }
-    const raw = (0, import_node_fs5.readFileSync)(sessionPath, "utf8");
+    const raw = (0, import_node_fs4.readFileSync)(sessionPath, "utf8");
     return JSON.parse(raw);
   }
 };
@@ -13642,10 +13723,9 @@ var BucketCommandHandler = class {
 };
 
 // src/commands/DeployCommandHandler.ts
-var import_node_fs6 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path7 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
-var import_yaml3 = __toESM(require("yaml"));
 
 // src/appDir.ts
 var import_node_path6 = __toESM(require("path"));
@@ -13695,11 +13775,12 @@ var DeployCommandHandler = class {
       );
     }
     const cwd = this.resolveCwd(args.deployCwd);
-    const config = this.loadConfig(cwd);
+    const loadedConfig = this.loadConfig(cwd);
+    const config = loadedConfig.config;
     const appConfig = config.apps.find((entry) => entry?.app === appName);
     if (!appConfig) {
       throw new Error(
-        `No app named ${appName} found in ${import_node_path7.default.join(cwd, ".pmate.yaml")}`
+        `No app named ${appName} found in ${describeLoadedAppConfig(loadedConfig)}`
       );
     }
     if (args.deployAction === "logs") {
@@ -13743,7 +13824,7 @@ 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_fs6.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs5.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -13753,7 +13834,7 @@ var DeployCommandHandler = class {
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], cwd);
     const distDir = import_node_path7.default.join(appDir, "dist");
-    if (!(0, import_node_fs6.existsSync)(distDir)) {
+    if (!(0, import_node_fs5.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const bucketName = appConfig.bucket?.trim();
@@ -13767,7 +13848,7 @@ var DeployCommandHandler = class {
   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_fs6.existsSync)(srcDir)) {
+    if (!(0, import_node_fs5.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const bucketName = appConfig.bucket?.trim();
@@ -13882,7 +13963,7 @@ var DeployCommandHandler = class {
     return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
   }
   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}`);
@@ -13890,16 +13971,7 @@ var DeployCommandHandler = class {
     return parsed;
   }
   loadConfig(cwd) {
-    const configPath = import_node_path7.default.join(cwd, ".pmate.yaml");
-    if (!(0, import_node_fs6.existsSync)(configPath)) {
-      throw new Error(`No .pmate.yaml found in ${cwd}`);
-    }
-    const raw = (0, import_node_fs6.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml3.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error("Invalid .pmate.yaml: missing apps array");
-    }
-    return parsed;
+    return loadAppConfig(cwd);
   }
   runCommand(command, args, cwd) {
     return new Promise((resolve, reject) => {
@@ -13969,11 +14041,10 @@ var DeployCommandHandler = class {
 };
 
 // src/commands/LogCommandHandler.ts
-var import_node_fs7 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_child_process3 = require("child_process");
 var import_node_path8 = __toESM(require("path"));
 var import_node_module = require("module");
-var import_yaml4 = __toESM(require("yaml"));
 var LogCommandHandler = class {
   async handle(args) {
     const appName = args.logApp.trim();
@@ -13981,14 +14052,13 @@ var LogCommandHandler = class {
       throw new Error("Missing app name. Usage: log <app-name> [--cwd <dir>].");
     }
     const cwd = this.resolveCwd(args.logCwd);
-    const { config, configPath } = this.loadClosestConfig(cwd);
+    const { config, configPath, repoRoot } = this.loadClosestConfig(cwd);
     const appConfig = config.apps.find((entry) => entry?.app === appName);
     if (!appConfig) {
       throw new Error(`No app named ${appName} found in ${configPath}`);
     }
     if (appConfig.type === "node") {
       const server = this.resolveNodeServer(appName, appConfig);
-      const repoRoot = import_node_path8.default.dirname(configPath);
       const pm2Name = this.resolvePm2AppName(repoRoot, appName, appConfig);
       await this.runRemotePm2Logs(server, pm2Name);
       return;
@@ -14005,30 +14075,12 @@ var LogCommandHandler = class {
     return target ? import_node_path8.default.resolve(process.cwd(), target) : process.cwd();
   }
   loadClosestConfig(cwd) {
-    const configPath = this.findRepoConfigPath(cwd);
-    if (!configPath) {
-      throw new Error(`No .pmate.yaml found in ${cwd} or parent directories`);
-    }
-    const raw = (0, import_node_fs7.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml4.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error(`Invalid .pmate.yaml: missing apps array (${configPath})`);
-    }
-    return { config: parsed, configPath };
-  }
-  findRepoConfigPath(cwd) {
-    let current = import_node_path8.default.resolve(cwd);
-    while (true) {
-      const candidate = import_node_path8.default.join(current, ".pmate.yaml");
-      if ((0, import_node_fs7.existsSync)(candidate)) {
-        return candidate;
-      }
-      const parent = import_node_path8.default.dirname(current);
-      if (parent === current) {
-        return null;
-      }
-      current = parent;
-    }
+    const loaded = loadAppConfig(cwd, { searchParents: true });
+    return {
+      config: loaded.config,
+      configPath: describeLoadedAppConfig(loaded),
+      repoRoot: loaded.rootDir
+    };
   }
   resolveNodeServer(appName, appConfig) {
     const server = appConfig.server?.trim();
@@ -14052,11 +14104,11 @@ var LogCommandHandler = class {
   }
   findEcosystemPath(appDir) {
     const cjs = import_node_path8.default.join(appDir, "ecosystem.config.cjs");
-    if ((0, import_node_fs7.existsSync)(cjs)) {
+    if ((0, import_node_fs6.existsSync)(cjs)) {
       return cjs;
     }
     const js = import_node_path8.default.join(appDir, "ecosystem.config.js");
-    if ((0, import_node_fs7.existsSync)(js)) {
+    if ((0, import_node_fs6.existsSync)(js)) {
       return js;
     }
     return null;
@@ -14157,11 +14209,11 @@ var LogCommandHandler = class {
 };
 
 // src/commands/InitCommandHandler.ts
-var import_node_fs8 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path9 = __toESM(require("path"));
 var import_node_child_process4 = require("child_process");
 var import_promises2 = require("readline/promises");
-var import_yaml5 = __toESM(require("yaml"));
+var import_yaml2 = __toESM(require("yaml"));
 
 // src/serverAddress.ts
 var import_promises = require("dns/promises");
@@ -14189,14 +14241,14 @@ var InitCommandHandler = class {
       throw new Error("Missing app name. Usage: init <app-name> [--cwd <dir>].");
     }
     const cwd = this.resolveCwd(args.initCwd);
-    const config = this.loadConfig(cwd);
+    const { config } = this.loadConfig(cwd);
     let appConfig = config.apps.find((entry) => entry?.app === appName);
     if (!appConfig) {
       appConfig = await this.addAppConfig(config, appName, cwd);
     }
     if (appConfig.type !== "rust") {
       const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
-      if (!(0, import_node_fs8.existsSync)(appDir)) {
+      if (!(0, import_node_fs7.existsSync)(appDir)) {
         throw new Error(`No app folder found at ${appDir}`);
       }
     }
@@ -14364,10 +14416,10 @@ var InitCommandHandler = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = serviceType === "ws" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = import_node_path9.default.join(__dirname, "..", "templates", templateName);
-      if (!(0, import_node_fs8.existsSync)(templatePath)) {
+      if (!(0, import_node_fs7.existsSync)(templatePath)) {
         throw new Error(`Missing nginx template at ${templatePath}`);
       }
-      const template = (0, import_node_fs8.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs7.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`;
@@ -14400,15 +14452,15 @@ var InitCommandHandler = class {
     if (options.ensurePackageJson) {
       const appDir = resolveLocalAppDir(cwd, appConfig.app, appConfig.dir);
       ui.info(`Resolved appDir: ${appDir}`);
-      if (!(0, import_node_fs8.existsSync)(appDir)) {
+      if (!(0, import_node_fs7.existsSync)(appDir)) {
         throw new Error(`Missing app folder at ${appDir}`);
       }
       const packageJsonPath = import_node_path9.default.join(appDir, "package.json");
       ui.info(`Resolved package.json: ${packageJsonPath}`);
-      if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
+      if (!(0, import_node_fs7.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs8.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs7.statSync)(packageJsonPath);
       ui.info(
         `package.json stat: isFile=${pkgStat.isFile()} isDirectory=${pkgStat.isDirectory()}`
       );
@@ -14474,16 +14526,7 @@ var InitCommandHandler = class {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   loadConfig(cwd) {
-    const configPath = import_node_path9.default.join(cwd, ".pmate.yaml");
-    if (!(0, import_node_fs8.existsSync)(configPath)) {
-      throw new Error(`No .pmate.yaml found in ${cwd}`);
-    }
-    const raw = (0, import_node_fs8.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml5.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error("Invalid .pmate.yaml: missing apps array");
-    }
-    return parsed;
+    return loadAppConfig(cwd);
   }
   async addAppConfig(config, appName, cwd) {
     ui.title(`App ${appName} not found in .pmate.yaml.`);
@@ -14601,7 +14644,7 @@ var InitCommandHandler = class {
     }
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs8.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs7.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -14610,13 +14653,13 @@ var InitCommandHandler = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs8.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs7.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   writeConfig(cwd, config) {
     const configPath = import_node_path9.default.join(cwd, ".pmate.yaml");
-    const serialized = import_yaml5.default.stringify(config).trimEnd();
-    (0, import_node_fs8.writeFileSync)(configPath, `${serialized}
+    const serialized = import_yaml2.default.stringify(config).trimEnd();
+    (0, import_node_fs7.writeFileSync)(configPath, `${serialized}
 `, "utf8");
   }
   async promptRequired(rl, question) {
@@ -14652,10 +14695,9 @@ var InitCommandHandler = class {
 };
 
 // src/commands/DevCommandHandler.ts
-var import_node_fs9 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path10 = __toESM(require("path"));
 var import_node_child_process5 = require("child_process");
-var import_yaml6 = __toESM(require("yaml"));
 var DevCommandHandler = class {
   async handle(args) {
     const appName = args.devApp.trim();
@@ -14663,16 +14705,17 @@ var DevCommandHandler = class {
       throw new Error("Missing app name. Usage: dev <app-name> [--cwd <dir>].");
     }
     const cwd = this.resolveCwd(args.devCwd);
-    const config = this.loadConfig(cwd);
+    const loadedConfig = this.loadConfig(cwd);
+    const config = loadedConfig.config;
     const appConfig = config.apps.find((entry) => entry?.app === appName);
     if (!appConfig) {
       throw new Error(
-        `No app named ${appName} found in ${import_node_path10.default.join(cwd, ".pmate.yaml")}`
+        `No app named ${appName} found in ${describeLoadedAppConfig(loadedConfig)}`
       );
     }
     const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
     const packageJsonPath = import_node_path10.default.join(appDir, "package.json");
-    if (!(0, import_node_fs9.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs8.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -14689,19 +14732,10 @@ var DevCommandHandler = class {
     return target ? import_node_path10.default.resolve(process.cwd(), target) : process.cwd();
   }
   loadConfig(cwd) {
-    const configPath = import_node_path10.default.join(cwd, ".pmate.yaml");
-    if (!(0, import_node_fs9.existsSync)(configPath)) {
-      throw new Error(`No .pmate.yaml found in ${cwd}`);
-    }
-    const raw = (0, import_node_fs9.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml6.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error("Invalid .pmate.yaml: missing apps array");
-    }
-    return parsed;
+    return loadAppConfig(cwd);
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs9.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs8.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -14729,7 +14763,7 @@ var DevCommandHandler = class {
 };
 
 // src/commands/OssCommandHandler.ts
-var import_node_fs10 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path11 = __toESM(require("path"));
 var import_promises3 = require("readline/promises");
 var OssCommandHandler = class {
@@ -14765,10 +14799,10 @@ var OssCommandHandler = class {
     }
   }
   assertFile(filePath) {
-    if (!(0, import_node_fs10.existsSync)(filePath)) {
+    if (!(0, import_node_fs9.existsSync)(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const stat = (0, import_node_fs10.statSync)(filePath);
+    const stat = (0, import_node_fs9.statSync)(filePath);
     if (!stat.isFile()) {
       throw new Error(`Not a file: ${filePath}`);
     }
@@ -14804,10 +14838,8 @@ var OssCommandHandler = class {
 };
 
 // src/commands/EnvCommandHandler.ts
-var import_node_fs11 = require("fs");
 var import_node_path12 = __toESM(require("path"));
 var import_node_child_process6 = require("child_process");
-var import_yaml7 = __toESM(require("yaml"));
 var EnvCommandHandler = class {
   async handle(args) {
     const appName = args.envApp.trim();
@@ -14816,14 +14848,12 @@ var EnvCommandHandler = class {
         "Missing app name. Usage: env <app-name> --list|--set KEY --value VALUE|--delete KEY [--cwd <dir>] [--verbose|-v]"
       );
     }
-    const config = this.loadConfig(args.envCwd);
+    const loadedConfig = this.loadConfig(args.envCwd);
+    const config = loadedConfig.config;
     const appConfig = config.apps.find((entry) => entry?.app === appName);
     if (!appConfig) {
       throw new Error(
-        `No app named ${appName} found in ${import_node_path12.default.join(
-          process.cwd(),
-          ".pmate.yaml"
-        )}`
+        `No app named ${appName} found in ${describeLoadedAppConfig(loadedConfig)}`
       );
     }
     if (appConfig.type !== "node") {
@@ -15091,16 +15121,7 @@ var EnvCommandHandler = class {
     }
   }
   loadConfig(cwd) {
-    const configPath = import_node_path12.default.join(cwd, ".pmate.yaml");
-    if (!(0, import_node_fs11.existsSync)(configPath)) {
-      throw new Error(`No .pmate.yaml found in ${cwd}`);
-    }
-    const raw = (0, import_node_fs11.readFileSync)(configPath, "utf8");
-    const parsed = import_yaml7.default.parse(raw);
-    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.apps)) {
-      throw new Error("Invalid .pmate.yaml: missing apps array");
-    }
-    return parsed;
+    return loadAppConfig(cwd);
   }
   runRemoteCommand(server, command) {
     return new Promise((resolve, reject) => {
@@ -16003,7 +16024,7 @@ function truncate2(value, limit) {
 
 // src/commands/LinearCommandHandler.ts
 var import_node_child_process9 = require("child_process");
-var import_node_fs13 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os5 = __toESM(require("os"));
 var import_node_path15 = __toESM(require("path"));
 var import_promises4 = require("readline/promises");
@@ -16893,11 +16914,11 @@ var LinearCommandHandler = class {
   }
   readCachedLinearSelection(cwd) {
     const selectionPath = this.getLinearSelectionPath();
-    if (!(0, import_node_fs13.existsSync)(selectionPath)) {
+    if (!(0, import_node_fs11.existsSync)(selectionPath)) {
       return void 0;
     }
     try {
-      const raw = (0, import_node_fs13.readFileSync)(selectionPath, "utf8").trim();
+      const raw = (0, import_node_fs11.readFileSync)(selectionPath, "utf8").trim();
       if (!raw) return void 0;
       const parsed = JSON.parse(raw);
       const value = parsed[cwd];
@@ -16909,11 +16930,11 @@ var LinearCommandHandler = class {
   writeCachedLinearSelection(cwd, title) {
     const selectionPath = this.getLinearSelectionPath();
     const dir = import_node_path15.default.dirname(selectionPath);
-    (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
     let data = {};
-    if ((0, import_node_fs13.existsSync)(selectionPath)) {
+    if ((0, import_node_fs11.existsSync)(selectionPath)) {
       try {
-        const raw = (0, import_node_fs13.readFileSync)(selectionPath, "utf8").trim();
+        const raw = (0, import_node_fs11.readFileSync)(selectionPath, "utf8").trim();
         if (raw) {
           data = JSON.parse(raw);
         }
@@ -16922,7 +16943,7 @@ var LinearCommandHandler = class {
       }
     }
     data[cwd] = title;
-    (0, import_node_fs13.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
+    (0, import_node_fs11.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   }
   async lookupIssue(client, issueRef) {
@@ -17099,14 +17120,14 @@ var LinearCommandHandler = class {
     if (process.platform !== "darwin") {
       throw new Error("Screenshot capture only supports macOS.");
     }
-    const dir = await import_node_fs13.promises.mkdtemp(import_node_path15.default.join(import_node_os5.default.tmpdir(), "pmate-screenshot-"));
+    const dir = await import_node_fs11.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`);
     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_fs13.promises.readFile(filePath);
+      const buffer = await import_node_fs11.promises.readFile(filePath);
       if (buffer.length === 0) {
         throw new Error("Screenshot capture produced an empty file.");
       }
@@ -17118,7 +17139,7 @@ var LinearCommandHandler = class {
       return { buffer, mime, filename: `screenshot-${index}.${extension}` };
     } finally {
       try {
-        await import_node_fs13.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs11.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -17262,17 +17283,17 @@ var LinearCommandHandler = class {
     return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
   }
   async convertToPng(buffer, ext) {
-    const dir = await import_node_fs13.promises.mkdtemp(import_node_path15.default.join(import_node_os5.default.tmpdir(), "pmate-"));
+    const dir = await import_node_fs11.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");
     try {
-      await import_node_fs13.promises.writeFile(inputPath, buffer);
+      await import_node_fs11.promises.writeFile(inputPath, buffer);
       const stderr = await this.runCapture(
         "sips",
         ["-s", "format", "png", inputPath, "--out", outputPath],
         true
       );
-      const out = await import_node_fs13.promises.readFile(outputPath);
+      const out = await import_node_fs11.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.`
@@ -17281,7 +17302,7 @@ var LinearCommandHandler = class {
       return out;
     } finally {
       try {
-        await import_node_fs13.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs11.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -17627,7 +17648,7 @@ function sleep(ms) {
 }
 
 // src/commands/NotionCommandHandler.ts
-var import_node_fs14 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path16 = __toESM(require("path"));
 
 // src/services/NotionService.ts
@@ -17968,13 +17989,13 @@ var NotionCommandHandler = class {
       return "";
     }
     const resolved = import_node_path16.default.resolve(process.cwd(), args.filePath);
-    return (0, import_node_fs14.readFileSync)(resolved, "utf8");
+    return (0, import_node_fs12.readFileSync)(resolved, "utf8");
   }
 };
 
 // src/commands/QrcodeCommandHandler.ts
 var import_node_child_process10 = require("child_process");
-var import_node_fs15 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os6 = __toESM(require("os"));
 var import_node_path17 = __toESM(require("path"));
 var import_promises5 = require("readline/promises");
@@ -18002,7 +18023,7 @@ var QrcodeCommandHandler = class {
       ui.success("QR code value:", value);
     } finally {
       try {
-        await import_node_fs15.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs13.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -18018,13 +18039,13 @@ var QrcodeCommandHandler = class {
     } finally {
       rl.close();
     }
-    const dir = await import_node_fs15.promises.mkdtemp(import_node_path17.default.join(import_node_os6.default.tmpdir(), "pmate-qrcode-"));
+    const dir = await import_node_fs13.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 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_fs15.promises.readFile(filePath);
+    const buffer = await import_node_fs13.promises.readFile(filePath);
     if (buffer.length === 0) {
       throw new Error("Screenshot capture produced an empty file.");
     }
@@ -18040,7 +18061,7 @@ var QrcodeCommandHandler = class {
   async decodeQr(filePath) {
     let buffer;
     try {
-      buffer = await import_node_fs15.promises.readFile(filePath);
+      buffer = await import_node_fs13.promises.readFile(filePath);
     } catch {
       return null;
     }
@@ -18300,7 +18321,7 @@ function clampNumber(value, min, max, fallback) {
 // src/commands/CollectCommandHandler.ts
 var import_playwright = require("playwright");
 var import_node_crypto3 = require("crypto");
-var import_node_fs16 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_os7 = __toESM(require("os"));
 var import_node_path18 = __toESM(require("path"));
 var CollectCommandHandler = class {
@@ -18677,11 +18698,11 @@ async function toDisplayableImagePath(src) {
     return src;
   }
   try {
-    const stat = await import_node_fs16.promises.stat(src);
+    const stat = await import_node_fs14.promises.stat(src);
     if (!stat.isFile()) {
       return src;
     }
-    const fh = await import_node_fs16.promises.open(src, "r");
+    const fh = await import_node_fs14.promises.open(src, "r");
     try {
       const buf = Buffer.alloc(32);
       const { bytesRead } = await fh.read(buf, 0, 32, 0);
@@ -18696,11 +18717,11 @@ async function toDisplayableImagePath(src) {
         "messages",
         "images"
       );
-      await import_node_fs16.promises.mkdir(cacheDir, { recursive: true });
+      await import_node_fs14.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_fs16.promises.rm(displayPath, { force: true }).catch(() => void 0);
-      await import_node_fs16.promises.copyFile(src, displayPath);
+      await import_node_fs14.promises.rm(displayPath, { force: true }).catch(() => void 0);
+      await import_node_fs14.promises.copyFile(src, displayPath);
       return displayPath;
     } finally {
       await fh.close();
@@ -18756,7 +18777,7 @@ function parseMessageText(raw) {
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs17 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_os8 = __toESM(require("os"));
 var import_node_path19 = __toESM(require("path"));
 var AgentCommandHandler = class {
@@ -18841,10 +18862,10 @@ var AgentCommandHandler = class {
   }
   readToken() {
     const sessionPath = import_node_path19.default.join(import_node_os8.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs17.existsSync)(sessionPath)) {
+    if (!(0, import_node_fs15.existsSync)(sessionPath)) {
       throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
     }
-    const raw = (0, import_node_fs17.readFileSync)(sessionPath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(sessionPath, "utf8");
     const parsed = JSON.parse(raw);
     const token = parsed.token?.trim();
     if (!token) {
@@ -18854,10 +18875,10 @@ var AgentCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18926,7 +18947,7 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs18 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_os9 = __toESM(require("os"));
 var import_node_path20 = __toESM(require("path"));
 var AppCommandHandler = class {
@@ -18998,10 +19019,10 @@ var AppCommandHandler = class {
   }
   readToken() {
     const sessionPath = import_node_path20.default.join(import_node_os9.default.homedir(), ".pmate", "session.json");
-    if (!(0, import_node_fs18.existsSync)(sessionPath)) {
+    if (!(0, import_node_fs16.existsSync)(sessionPath)) {
       throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
     }
-    const raw = (0, import_node_fs18.readFileSync)(sessionPath, "utf8");
+    const raw = (0, import_node_fs16.readFileSync)(sessionPath, "utf8");
     const parsed = JSON.parse(raw);
     const token = parsed.token?.trim();
     if (!token) {
@@ -19011,10 +19032,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19431,7 +19452,7 @@ function requireValue2(tokens, optionName) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs19.readFileSync)(import_node_path21.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs17.readFileSync)(import_node_path21.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk3.default.bold(`pmate v${pkg.version}`),