@pmate/cli 0.25.7 → 0.25.9

package/README.md

@@ -50,8 +50,9 @@ pmate vercel projects
 pmate vercel deploys --project web --last-week
 pmate im1 health
 pmate im1 threads --limit 20
+pmate im1 threads --search "titlte" --limit 5
 pmate im1 messages --thread "<conversationId-or-thread-name>" --limit 50
-pmate im1 reply --source cc --thread "<conversationId-or-thread-name>" --text "hello"
+pmate im1 reply --thread "<conversationId-or-thread-name>" --text "hello"
 ```
 
 Notes:
@@ -175,8 +176,9 @@ Useful commands:
 pmate im1 health
 pmate im1 threads --limit 20
 pmate im1 threads --q Bug --limit 10
+pmate im1 threads --search "titlte" --limit 5
 pmate im1 messages --thread "<conversationId-or-thread-name>" --limit 50
-pmate im1 reply --source cc --thread "<conversationId-or-thread-name>" --text "hello"
+pmate im1 reply --thread "<conversationId-or-thread-name>" --text "hello"
 ```
 
 `threads` and `messages` output JSON by default. Thread rows include both
@@ -184,11 +186,15 @@ pmate im1 reply --source cc --thread "<conversationId-or-thread-name>" --text "h
 passing a thread back into `messages`/`reply`. Add `--text` for compact
 human-readable output.
 
+Use `pmate im1 threads --search "<title>"` for fuzzy title lookup. It compares
+the lowercased search text against thread titles with edit distance, including
+nearby token/window matches for typos such as `titlte` vs `title`. JSON output
+includes `searchDistance` and `searchScore`.
+
 CC sync is owned by the background service in `~/dev/pcs/cc-bot`, which runs
 under PM2, keeps TimescaleDB running, listens for new CC messages, and performs
-bounded 3-day backfill. `pmate im1 collect sync --source cc` is intentionally
-disabled. Legacy yelling/custom endpoint collection still uses
-`pmate im1 collect sync --source yelling` or `--endpoint`.
+bounded 3-day backfill. `pmate im1` is CC-only and does not accept `--source`
+or custom `--endpoint` options.
 
 ## Notion config
 

package/dist/index.d.ts

@@ -452,6 +452,47 @@ type AccountCommandArgs = {
     role?: "practitioner" | "mate";
     baseUrl?: string;
     json: boolean;
+} | {
+    type: Command.Account;
+    action: "access-key-create";
+    app: string;
+    name: string;
+    namespace?: string;
+    scopes: string[];
+    expiresAt: string;
+    out?: string;
+    baseUrl?: string;
+    json: boolean;
+} | {
+    type: Command.Account;
+    action: "access-key-list";
+    app?: string;
+    namespace?: string;
+    baseUrl?: string;
+    json: boolean;
+} | {
+    type: Command.Account;
+    action: "access-key-disable";
+    id: string;
+    baseUrl?: string;
+    json: boolean;
+} | {
+    type: Command.Account;
+    action: "access-key-rotate";
+    id: string;
+    expiresAt: string;
+    gracePeriodSeconds?: number;
+    out?: string;
+    baseUrl?: string;
+    json: boolean;
+} | {
+    type: Command.Account;
+    action: "access-key-login";
+    app: string;
+    key?: string;
+    keyFile?: string;
+    baseUrl?: string;
+    json: boolean;
 };
 type OrgCommandArgs = {
     type: Command.Org;
@@ -554,22 +595,19 @@ type CollectCommandArgs = {
 } | {
     type: Command.Collect;
     action: "threads";
-    source?: "cc";
     query?: string;
+    search?: string;
     limit?: number;
     json?: boolean;
 } | {
     type: Command.Collect;
     action: "messages";
-    source?: "cc";
     thread: string;
     limit?: number;
     json?: boolean;
 } | {
     type: Command.Collect;
     action: "reply";
-    source?: "cc" | "yelling";
-    endpoint?: string;
     thread: string;
     text: string;
     dryRun: boolean;

package/dist/index.js

@@ -15748,21 +15748,15 @@ var CollectCommandHandler = class {
       await this.handleBotMessages(args);
       return;
     }
-    if (args.source === "cc" && !args.endpoint) {
-      if (args.action === "sync") {
-        throw new Error(
-          'pmate im1 collect sync has moved to cc-bot. Start ~/dev/pcs/cc-bot and use "pmate im1 threads", "pmate im1 messages", or "pmate im1 reply".'
-        );
-      }
-      if (args.action === "reply") {
-        await this.handleBotReply(args);
-        return;
-      }
-    }
     if (args.action === "reply") {
-      await this.handleReply(args);
+      await this.handleBotReply(args);
       return;
     }
+    if (args.source === "cc" && !args.endpoint) {
+      throw new Error(
+        'CC sync has moved to cc-bot. Start ~/dev/pcs/cc-bot and use "pmate im1 threads", "pmate im1 messages", or "pmate im1 reply".'
+      );
+    }
     await this.handleSync(args);
   }
   async handleBotHealth() {
@@ -15771,12 +15765,14 @@ var CollectCommandHandler = class {
   }
   async handleBotThreads(args) {
     const client = new Im1BotClient();
-    const threads = await client.listThreads({ q: args.query, limit: args.limit });
+    const fetchLimit = args.search ? Math.max(args.limit ?? 10, 200) : args.limit;
+    const threads = await client.listThreads({ q: args.query, limit: fetchLimit });
+    const outputThreads = args.search ? rankThreadsByTitleSearch(threads, args.search).slice(0, args.limit ?? 10) : threads;
     if (args.json !== false) {
-      ui.plain(JSON.stringify({ ok: true, threads }, null, 2));
+      ui.plain(JSON.stringify({ ok: true, threads: outputThreads }, null, 2));
       return;
     }
-    for (const thread of threads) {
+    for (const thread of outputThreads) {
       ui.plain(formatBotThread(thread));
     }
   }
@@ -16179,9 +16175,88 @@ function isExternalImageRef(imagePath) {
 }
 function formatBotThread(thread) {
   const unread = thread.unread && thread.unread > 0 ? ` unread=${thread.unread}` : "";
+  const distance = typeof thread.searchDistance === "number" ? ` distance=${thread.searchDistance}` : "";
   const time = thread.lastMessageAt ? ` ${thread.lastMessageAt}` : "";
   const preview = thread.preview ? ` - ${truncateCliPreview(thread.preview, 120)}` : "";
-  return `${thread.name} (${thread.conversationId})${unread}${time}${preview}`;
+  return `${thread.name} (${thread.conversationId})${unread}${distance}${time}${preview}`;
+}
+function rankThreadsByTitleSearch(threads, rawSearch) {
+  const search = normalizeSearchTitle(rawSearch);
+  if (!search) {
+    return threads.map((thread) => ({
+      ...thread,
+      search: rawSearch,
+      searchDistance: 0,
+      searchScore: 1
+    }));
+  }
+  return threads.map((thread) => {
+    const title = normalizeSearchTitle(thread.name);
+    const distance = fuzzyTitleDistance(search, title);
+    const score = 1 - distance / Math.max(search.replace(/\s+/g, "").length, 1);
+    return {
+      ...thread,
+      search: rawSearch,
+      searchDistance: distance,
+      searchScore: Number(Math.max(0, score).toFixed(4))
+    };
+  }).sort((left, right) => {
+    if ((left.searchDistance ?? 0) !== (right.searchDistance ?? 0)) {
+      return (left.searchDistance ?? 0) - (right.searchDistance ?? 0);
+    }
+    if ((left.searchScore ?? 0) !== (right.searchScore ?? 0)) {
+      return (right.searchScore ?? 0) - (left.searchScore ?? 0);
+    }
+    return compareNullableIsoDesc(left.lastMessageAt, right.lastMessageAt);
+  });
+}
+function fuzzyTitleDistance(search, title) {
+  if (!search) return 0;
+  if (!title) return search.length;
+  if (title.includes(search)) return 0;
+  const compactSearch = search.replace(/\s+/g, "");
+  const compactTitle = title.replace(/\s+/g, "");
+  const candidates = /* @__PURE__ */ new Set([title, compactTitle]);
+  for (const token of title.split(/\s+/)) {
+    if (token) candidates.add(token);
+  }
+  if (compactSearch && compactTitle.length >= compactSearch.length) {
+    for (let index = 0; index <= compactTitle.length - compactSearch.length; index += 1) {
+      candidates.add(compactTitle.slice(index, index + compactSearch.length));
+    }
+  }
+  let best = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    best = Math.min(best, damerauLevenshteinDistance(compactSearch || search, candidate));
+  }
+  return Number.isFinite(best) ? best : search.length;
+}
+function normalizeSearchTitle(value) {
+  return value.toLowerCase().normalize("NFKC").replace(/[\p{P}\p{S}]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+function damerauLevenshteinDistance(left, right) {
+  const matrix = Array.from({ length: left.length + 1 }, () => Array(right.length + 1).fill(0));
+  for (let row = 0; row <= left.length; row += 1) matrix[row][0] = row;
+  for (let column = 0; column <= right.length; column += 1) matrix[0][column] = column;
+  for (let row = 1; row <= left.length; row += 1) {
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      matrix[row][column] = Math.min(
+        matrix[row - 1][column] + 1,
+        matrix[row][column - 1] + 1,
+        matrix[row - 1][column - 1] + cost
+      );
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        matrix[row][column] = Math.min(matrix[row][column], matrix[row - 2][column - 2] + 1);
+      }
+    }
+  }
+  return matrix[left.length][right.length];
+}
+function compareNullableIsoDesc(left, right) {
+  const leftTime = left ? Date.parse(left) : 0;
+  const rightTime = right ? Date.parse(right) : 0;
+  return rightTime - leftTime;
 }
 function formatBotMessage(message) {
   const sender = message.sender ? `${message.sender}: ` : "";
@@ -22228,6 +22303,88 @@ var AccountCommandHandler = class {
         this.renderJson(profile, args.json);
         return;
       }
+      case "access-key-create": {
+        const token = this.readToken();
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const result = await this.request(
+          baseUrl,
+          token,
+          "POST",
+          "/access-keys",
+          {
+            app: args.app,
+            name: args.name,
+            namespace: args.namespace,
+            scopes: args.scopes,
+            expiresAt: args.expiresAt
+          }
+        );
+        this.persistAccessKeySecret(result, args.out);
+        this.renderAccessKeyCreateResult(result, args.json, args.out);
+        return;
+      }
+      case "access-key-list": {
+        const token = this.readToken();
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const result = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          `/access-keys?${this.buildAccessKeyListQuery(args)}`
+        );
+        this.renderAccessKeys(result.items, args.json);
+        return;
+      }
+      case "access-key-disable": {
+        const token = this.readToken();
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const item = await this.request(
+          baseUrl,
+          token,
+          "DELETE",
+          `/access-keys/${encodeURIComponent(args.id)}`
+        );
+        if (!args.json) {
+          ui.success(`Disabled access key ${item.id}`);
+        }
+        this.renderJson(item, args.json);
+        return;
+      }
+      case "access-key-rotate": {
+        const token = this.readToken();
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const result = await this.request(
+          baseUrl,
+          token,
+          "POST",
+          `/access-keys/${encodeURIComponent(args.id)}/rotate`,
+          {
+            expiresAt: args.expiresAt,
+            gracePeriodSeconds: args.gracePeriodSeconds
+          }
+        );
+        this.persistAccessKeySecret(result, args.out);
+        this.renderAccessKeyCreateResult(result, args.json, args.out);
+        return;
+      }
+      case "access-key-login": {
+        const baseUrl = this.resolveAuthBaseUrl(args.baseUrl);
+        const secret = args.key ?? this.readAccessKeyFile(args.keyFile, args.app).secret;
+        const login = await this.request(
+          baseUrl,
+          secret,
+          "POST",
+          "/access-keys/session",
+          { app: args.app }
+        );
+        const profileId = await this.resolveLoginProfileId(login, args.app, baseUrl);
+        const saved = saveLoginSession({ ...login, profileId }, args.app);
+        if (!args.json) {
+          ui.success(`Logged in access key ${login.session.identity.accessKeyId ?? "unknown"} to ${saved.app}`);
+        }
+        this.renderJson(login, args.json);
+        return;
+      }
     }
   }
   resolveAuthBaseUrl(baseUrl) {
@@ -22269,6 +22426,12 @@ var AccountCommandHandler = class {
     if (args.namespace) params.set("namespace", args.namespace);
     return params.toString();
   }
+  buildAccessKeyListQuery(args) {
+    const params = new URLSearchParams();
+    if (args.app) params.set("app", args.app);
+    if (args.namespace) params.set("namespace", args.namespace);
+    return params.toString();
+  }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
       method,
@@ -22426,6 +22589,9 @@ var AccountCommandHandler = class {
   resolveDefaultBotKeyPath(app, name) {
     return import_node_path26.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
   }
+  resolveDefaultAccessKeyPath(app, name) {
+    return import_node_path26.default.join(this.homeDir(), ".pmate", "access-keys", app, `${name}.access-key.json`);
+  }
   homeDir() {
     return process.env.HOME || process.env.USERPROFILE || process.cwd();
   }
@@ -22462,6 +22628,89 @@ var AccountCommandHandler = class {
     }
     return parsed;
   }
+  readAccessKeyFile(filePath, expectedApp) {
+    if (!filePath) {
+      throw new Error("Missing access key file");
+    }
+    const absolutePath = this.resolveFilePath(filePath);
+    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
+      throw new Error(`Access key file not found: ${absolutePath}`);
+    }
+    const parsed = JSON.parse((0, import_node_fs22.readFileSync)(absolutePath, "utf8"));
+    if (parsed.type !== "pmate-access-key" || parsed.version !== 1 || !parsed.id || !parsed.app || !parsed.secret || !parsed.expiresAt) {
+      throw new Error(`Invalid PMate access key file: ${absolutePath}`);
+    }
+    if (expectedApp && parsed.app !== expectedApp) {
+      throw new Error(`Access key app mismatch. expected=${expectedApp}, received=${parsed.app}`);
+    }
+    return parsed;
+  }
+  persistAccessKeySecret(result, out) {
+    const keyFile = {
+      type: "pmate-access-key",
+      version: 1,
+      id: result.key.id,
+      app: result.key.app,
+      name: result.key.name,
+      namespace: result.key.namespace,
+      secret: result.secret,
+      expiresAt: result.key.expiresAt,
+      createdAt: result.key.createdAt
+    };
+    const outPath = out ? this.resolveFilePath(out) : this.resolveDefaultAccessKeyPath(result.key.app, result.key.name);
+    (0, import_node_fs22.mkdirSync)(import_node_path26.default.dirname(outPath), { recursive: true });
+    (0, import_node_fs22.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
+    (0, import_node_fs22.chmodSync)(outPath, 384);
+  }
+  renderAccessKeyCreateResult(result, asJson, out) {
+    if (asJson) {
+      this.renderJson(result, true);
+      return;
+    }
+    const outPath = out ? this.resolveFilePath(out) : this.resolveDefaultAccessKeyPath(result.key.app, result.key.name);
+    ui.success(`Access key saved to ${outPath}`);
+    ui.info(result.key.id, {
+      app: result.key.app,
+      name: result.key.name,
+      namespace: result.key.namespace,
+      scopes: result.key.scopes,
+      expiresAt: result.key.expiresAt
+    });
+  }
+  renderAccessKeys(items, asJson) {
+    if (asJson) {
+      this.renderJson({ items }, true);
+      return;
+    }
+    if (items.length === 0) {
+      ui.warn("No access keys found.");
+      return;
+    }
+    for (const item of items) {
+      ui.info(item.id, {
+        app: item.app,
+        name: item.name,
+        namespace: item.namespace,
+        scopes: item.scopes,
+        status: item.status,
+        expiresAt: item.expiresAt,
+        lastUsedAt: item.lastUsedAt,
+        rotationExpiresAt: item.rotationExpiresAt
+      });
+    }
+  }
+  async resolveLoginProfileId(login, app, authApiBaseUrl) {
+    try {
+      return await fetchDefaultProfileId({
+        token: login.token,
+        app,
+        accountId: login.session.identity.accountId,
+        authApiBaseUrl
+      });
+    } catch {
+      return login.session.identity.accessKeyId ?? login.session.identity.accountId;
+    }
+  }
   signBotChallenge(challenge, privateKey) {
     const key = (0, import_node_crypto5.createPrivateKey)({
       key: Buffer.from(privateKey, "base64url"),
@@ -25264,6 +25513,104 @@ function parseAccountArgs(tokens) {
     }
     throw new Error(`Unknown account bot action: ${botAction}`);
   }
+  if (action === "access-key") {
+    const keyAction = rest.shift();
+    if (!keyAction) {
+      throw new Error("Missing account access-key action. Use: account access-key create|list|rotate|disable|login");
+    }
+    let app;
+    let id;
+    let name;
+    let namespace2;
+    const scopes = [];
+    let expiresAt;
+    let out;
+    let key;
+    let keyFile;
+    let gracePeriodSeconds;
+    let baseUrl2;
+    let json2 = false;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--app":
+          app = parseNamespacedRef(requireValue8(rest, token), {
+            entityLabel: "app ref"
+          }).fullId;
+          break;
+        case "--name":
+          name = requireValue8(rest, token);
+          break;
+        case "--namespace":
+          namespace2 = requireValue8(rest, token);
+          break;
+        case "--scope":
+          scopes.push(requireValue8(rest, token));
+          break;
+        case "--expires-at":
+          expiresAt = requireValue8(rest, token);
+          break;
+        case "--expires-in":
+          expiresAt = parseExpiresIn(requireValue8(rest, token));
+          break;
+        case "--grace-period":
+          gracePeriodSeconds = parseDurationSeconds(requireValue8(rest, token), token);
+          break;
+        case "--out":
+          out = requireValue8(rest, token);
+          break;
+        case "--key":
+          key = requireValue8(rest, token);
+          break;
+        case "--key-file":
+          keyFile = requireValue8(rest, token);
+          break;
+        case "--base-url":
+          baseUrl2 = requireValue8(rest, token);
+          break;
+        case "--json":
+          json2 = true;
+          break;
+        default:
+          if ((keyAction === "rotate" || keyAction === "disable") && !token.startsWith("-")) {
+            if (id) {
+              throw new Error(`Unexpected account access-key id: ${token}`);
+            }
+            id = token;
+            continue;
+          }
+          throw new Error(`Unknown account access-key option: ${token}`);
+      }
+    }
+    if (keyAction === "create") {
+      if (!app || !name || scopes.length === 0 || !expiresAt) {
+        throw new Error("Usage: account access-key create --app <ns:app> --name <name> --scope <scope>... (--expires-at <iso> | --expires-in <duration>) [--namespace <ns>] [--out <path>] [--base-url <url>] [--json]");
+      }
+      return { type: "account" /* Account */, action: "access-key-create", app, name, namespace: namespace2, scopes, expiresAt, out, baseUrl: baseUrl2, json: json2 };
+    }
+    if (keyAction === "list") {
+      return { type: "account" /* Account */, action: "access-key-list", app, namespace: namespace2, baseUrl: baseUrl2, json: json2 };
+    }
+    if (keyAction === "disable") {
+      if (!id) {
+        throw new Error("Usage: account access-key disable <id> [--base-url <url>] [--json]");
+      }
+      return { type: "account" /* Account */, action: "access-key-disable", id, baseUrl: baseUrl2, json: json2 };
+    }
+    if (keyAction === "rotate") {
+      if (!id || !expiresAt) {
+        throw new Error("Usage: account access-key rotate <id> (--expires-at <iso> | --expires-in <duration>) [--grace-period <duration>] [--out <path>] [--base-url <url>] [--json]");
+      }
+      return { type: "account" /* Account */, action: "access-key-rotate", id, expiresAt, gracePeriodSeconds, out, baseUrl: baseUrl2, json: json2 };
+    }
+    if (keyAction === "login") {
+      if (!app || !key && !keyFile || key && keyFile) {
+        throw new Error("Usage: account access-key login --app <ns:app> (--key <secret> | --key-file <path>) [--base-url <url>] [--json]");
+      }
+      return { type: "account" /* Account */, action: "access-key-login", app, key, keyFile, baseUrl: baseUrl2, json: json2 };
+    }
+    throw new Error(`Unknown account access-key action: ${keyAction}`);
+  }
   if (action !== "role") {
     throw new Error(`Unknown account action: ${action}`);
   }
@@ -25345,6 +25692,19 @@ function parsePositiveInt(value, optionName) {
   }
   return parsed;
 }
+function parseExpiresIn(value) {
+  return new Date(Date.now() + parseDurationSeconds(value, "--expires-in") * 1e3).toISOString();
+}
+function parseDurationSeconds(value, optionName) {
+  const match = /^(\d+)(s|m|h|d)?$/.exec(value.trim());
+  if (!match) {
+    throw new Error(`${optionName} must be a duration like 3600s, 60m, 24h, or 30d`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2] ?? "s";
+  const multiplier = unit === "d" ? 86400 : unit === "h" ? 3600 : unit === "m" ? 60 : 1;
+  return amount * multiplier;
+}
 
 // src/orgCommandParser.ts
 init_namespacedRef();
@@ -25683,10 +26043,7 @@ function parseIm1Args(tokens) {
   const rest = [...tokens];
   const action = rest.shift();
   if (!action) {
-    throw new Error("Usage: im1 collect sync (--source <cc|yelling> | --endpoint <url>) | im1 reply --thread <name> --text <text> (--source <cc|yelling> | --endpoint <url>)");
-  }
-  if (action === "collect") {
-    return parseIm1CollectArgs(rest);
+    throw new Error("Usage: im1 health | im1 threads [--q <keyword>] [--search <title>] | im1 messages --thread <name|conversation-id> | im1 reply --thread <name|conversation-id> --text <text>");
   }
   if (action === "health") {
     return parseIm1HealthArgs(rest);
@@ -25720,22 +26077,19 @@ function parseIm1HealthArgs(tokens) {
 function parseIm1ThreadsArgs(tokens) {
   const rest = [...tokens];
   let query;
+  let search;
   let limit;
-  let source = "cc";
   let json = true;
   while (rest.length > 0) {
     const token = rest.shift();
     switch (token) {
-      case "--source": {
-        const value = requireValue11(rest, token);
-        if (value !== "cc") throw new Error(`Unsupported im1 threads source: ${value}`);
-        source = value;
-        break;
-      }
       case "--q":
       case "--query":
         query = requireValue11(rest, token);
         break;
+      case "--search":
+        search = requireValue11(rest, token);
+        break;
       case "--limit":
         limit = parsePositiveInt2(requireValue11(rest, token), token);
         break;
@@ -25749,23 +26103,16 @@ function parseIm1ThreadsArgs(tokens) {
         throw new Error(`Unknown im1 threads option: ${token}`);
     }
   }
-  return { type: "collect" /* Collect */, action: "threads", source, query, limit, json };
+  return { type: "collect" /* Collect */, action: "threads", query, search, limit, json };
 }
 function parseIm1MessagesArgs(tokens) {
   const rest = [...tokens];
   let thread;
   let limit;
-  let source = "cc";
   let json = true;
   while (rest.length > 0) {
     const token = rest.shift();
     switch (token) {
-      case "--source": {
-        const value = requireValue11(rest, token);
-        if (value !== "cc") throw new Error(`Unsupported im1 messages source: ${value}`);
-        source = value;
-        break;
-      }
       case "--thread":
       case "--channel":
         thread = requireValue11(rest, token);
@@ -25786,33 +26133,10 @@ function parseIm1MessagesArgs(tokens) {
   if (!thread) {
     throw new Error("Usage: im1 messages --thread <name|conversation-id> [--limit <n>]");
   }
-  return { type: "collect" /* Collect */, action: "messages", source, thread, limit, json };
-}
-function parseIm1CollectArgs(tokens) {
-  const rest = [...tokens];
-  const action = rest.shift();
-  if (action !== "sync") {
-    throw new Error(
-      "Usage: im1 collect sync [--thread <name|conversation-id>] (--source <cc|yelling> | --endpoint <url>)"
-    );
-  }
-  const target = parseTargetOptions(rest);
-  if (!target.source && !target.endpoint) {
-    throw new Error(
-      "Usage: im1 collect sync [--thread <name|conversation-id>] (--source <cc|yelling> | --endpoint <url>)"
-    );
-  }
-  return {
-    type: "collect" /* Collect */,
-    action: "sync",
-    source: target.source,
-    endpoint: target.endpoint,
-    thread: target.thread
-  };
+  return { type: "collect" /* Collect */, action: "messages", thread, limit, json };
 }
 function parseIm1ReplyArgs(tokens) {
   const rest = [...tokens];
-  const targetTokens = [];
   let thread;
   let text;
   let dryRun = false;
@@ -25829,61 +26153,21 @@ function parseIm1ReplyArgs(tokens) {
       case "--dry-run":
         dryRun = true;
         break;
-      case "--source":
-      case "--endpoint":
-        targetTokens.push(token, requireValue11(rest, token));
-        break;
       default:
         throw new Error(`Unknown im1 reply option: ${token}`);
     }
   }
   if (!thread || !text) {
-    throw new Error("Usage: im1 reply --thread <name> --text <text> (--source <cc|yelling> | --endpoint <url>)");
-  }
-  const target = parseTargetOptions(targetTokens);
-  if (!target.source && !target.endpoint) {
-    throw new Error("Usage: im1 reply --thread <name> --text <text> (--source <cc|yelling> | --endpoint <url>)");
+    throw new Error("Usage: im1 reply --thread <name|conversation-id> --text <text>");
   }
   return {
     type: "collect" /* Collect */,
     action: "reply",
-    source: target.source,
-    endpoint: target.endpoint,
     thread,
     text,
     dryRun
   };
 }
-function parseTargetOptions(tokens) {
-  const rest = [...tokens];
-  const options = {};
-  while (rest.length > 0) {
-    const token = rest.shift();
-    switch (token) {
-      case "--source": {
-        const value = requireValue11(rest, token);
-        if (value !== "cc" && value !== "yelling") {
-          throw new Error(`Unsupported im1 source: ${value}`);
-        }
-        options.source = value;
-        break;
-      }
-      case "--endpoint":
-        options.endpoint = requireValue11(rest, token);
-        break;
-      case "--thread":
-      case "--channel":
-        options.thread = requireValue11(rest, token);
-        break;
-      default:
-        throw new Error(`Unknown im1 option: ${token}`);
-    }
-  }
-  if (options.source && options.endpoint) {
-    throw new Error("Use either --source or --endpoint, not both.");
-  }
-  return options;
-}
 function requireValue11(tokens, optionName) {
   const value = tokens.shift();
   if (!value || value.startsWith("--")) {
@@ -26120,10 +26404,9 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  --easy [--words <n>] [--digits <n>] [--separator <s>] [--count <n>]")}`,
   `  ${import_chalk4.default.cyan("im1")}               Read and reply to local CC messages through cc-bot`,
   `  ${import_chalk4.default.gray("                  health [--json]")}`,
-  `  ${import_chalk4.default.gray("                  threads [--q <keyword>] [--limit <n>] [--json|--text]")}`,
+  `  ${import_chalk4.default.gray("                  threads [--q <keyword>] [--search <title>] [--limit <n>] [--json|--text]")}`,
   `  ${import_chalk4.default.gray("                  messages --thread <name|conversation-id> [--limit <n>] [--json|--text]")}`,
-  `  ${import_chalk4.default.gray("                  collect sync [--thread <name|conversation-id>] (--source <cc|yelling> | --endpoint <url>)")}`,
-  `  ${import_chalk4.default.gray("                  reply --thread <name> --text <text> (--source <cc|yelling> | --endpoint <url>)")}`,
+  `  ${import_chalk4.default.gray("                  reply --thread <name|conversation-id> --text <text> [--dryrun]")}`,
   `  ${import_chalk4.default.cyan("collect")}          Legacy alias for CC/yelling collection`,
   `  ${import_chalk4.default.gray("                  sync [--thread <name|conversation-id>] (--source <cc|yelling> | --endpoint <url>)")}`,
   `  ${import_chalk4.default.cyan("chat-room")}        Run social chat regression commands with PMate bot key JSON`,
@@ -26175,6 +26458,11 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  bot list --app <ns:app> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  bot login --app <ns:app> --name <name> (--key-file <path> | --private-key <key>) [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  bot profile create --app <ns:app> --name <name> --nickname <nickname> [--role <role>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  access-key create --app <ns:app> --name <name> --scope <scope>... (--expires-at <iso> | --expires-in <duration>) [--namespace <ns>] [--out <path>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  access-key list [--app <ns:app>] [--namespace <ns>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  access-key rotate <id> (--expires-at <iso> | --expires-in <duration>) [--grace-period <duration>] [--out <path>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  access-key disable <id> [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  access-key login --app <ns:app> (--key <secret> | --key-file <path>) [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  default base URL: https://auth-api-v2.pmate.chat")}`,
   `  ${import_chalk4.default.cyan("org")}              Manage orgs, org members, and org visible apps via apps-api`,
   `  ${import_chalk4.default.gray("                  list [--base-url <url>] [--json]")}`,

package/package.json

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