@pmate/cli 0.14.0 → 0.16.0

package/dist/index.js

@@ -12612,8 +12612,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs14 = require("fs");
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path20 = __toESM(require("path"));
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -13827,12 +13827,107 @@ var StsCommandHandler = class {
   }
 };
 
+// src/staticSiteSetup.ts
+async function setupStaticSiteBucket(input) {
+  const bucketName = input.bucketName.trim();
+  const domainName = input.domainName.trim();
+  const subdomain = input.subdomain?.trim();
+  const dnsRr = subdomain || "@";
+  const cdnDomain = subdomain ? `${subdomain}.${domainName}` : domainName;
+  await AliyunService.ensureBucket(bucketName);
+  await sleep(2e3);
+  await AliyunService.ensureCdnDomain(cdnDomain, bucketName);
+  await sleep(2e3);
+  await AliyunService.enableOssPrivateBucketOrigin(cdnDomain);
+  await sleep(2e3);
+  ui.success(`Enabled OSS private bucket origin for ${cdnDomain}`);
+  await AliyunService.setDefaultCacheRules(cdnDomain);
+  await sleep(2e3);
+  ui.success(`Set default cache rules for ${cdnDomain}`);
+  const cname = await AliyunService.getCdnCname(cdnDomain);
+  if (!cname) {
+    throw new Error(`No CNAME found for ${cdnDomain}. Try again in a minute.`);
+  }
+  ui.info(`CNAME for ${cdnDomain}:`, cname);
+  const existingCname = await AliyunService.getCnameRecordValue(domainName, dnsRr);
+  if (existingCname) {
+    if (existingCname !== cname) {
+      throw new Error(
+        `Existing CNAME record for ${cdnDomain} points to ${existingCname}, not ${cname}.`
+      );
+    }
+    ui.success(`CNAME record already exists for ${cdnDomain}`);
+  } else {
+    await AliyunService.addRecord({
+      domainName,
+      rr: dnsRr,
+      type: "CNAME",
+      value: cname,
+      ttl: 600
+    });
+    await sleep(2e3);
+    ui.success(`Added CNAME record ${cdnDomain} -> ${cname}`);
+  }
+  if (!subdomain) {
+    const wwwCname = await AliyunService.getCnameRecordValue(domainName, "www");
+    if (wwwCname) {
+      if (wwwCname !== domainName) {
+        throw new Error(
+          `Existing CNAME record for www.${domainName} points to ${wwwCname}, not ${domainName}.`
+        );
+      }
+      ui.success(`CNAME record already exists for www.${domainName}`);
+    } else {
+      await AliyunService.addRecord({
+        domainName,
+        rr: "www",
+        type: "CNAME",
+        value: domainName,
+        ttl: 600
+      });
+      await sleep(2e3);
+      ui.success(`Added CNAME record www.${domainName} -> ${domainName}`);
+    }
+  }
+  await AliyunService.enableHttpsCertificate(cdnDomain);
+  await sleep(2e3);
+  ui.success(`Enabled HTTPS certificate for ${cdnDomain}`);
+  if (input.routeType === "ssg") {
+    await AliyunService.enableSsgRewriteRule(cdnDomain);
+    await sleep(2e3);
+    ui.success(`Enabled SSG rewrite rule for ${cdnDomain}`);
+    return;
+  }
+  await AliyunService.enableSpaRewriteRule(cdnDomain);
+  await sleep(2e3);
+  ui.success(`Enabled SPA rewrite rule for ${cdnDomain}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 // src/commands/BucketCommandHandler.ts
 var BucketCommandHandler = class {
   async handle(args) {
     const bucketName = args.bucketName.trim();
-    await AliyunService.createBucket(bucketName);
-    ui.success(`Bucket created: ${bucketName}`);
+    const subdomain = args.bucketSubdomain?.trim();
+    if (!subdomain) {
+      await AliyunService.createBucket(bucketName);
+      ui.success(`Bucket created: ${bucketName}`);
+      return;
+    }
+    const domainName = args.bucketDomain?.trim();
+    if (!domainName) {
+      throw new Error("Missing domain name. Use --domain <name> when --subdomain is set.");
+    }
+    await setupStaticSiteBucket({
+      bucketName,
+      domainName,
+      subdomain,
+      routeType: "spa"
+    });
   }
 };
 
@@ -14301,82 +14396,12 @@ var InitCommandHandler = class {
     if (!baseDomain) {
       throw new Error(`Missing domain in ${import_node_path8.default.join(cwd, ".pmate.yaml")}`);
     }
-    const subdomain = appConfig.subdomain?.trim();
-    const dnsRr = subdomain || "@";
-    const cdnDomain = subdomain ? `${subdomain}.${baseDomain}` : baseDomain;
-    await AliyunService.ensureBucket(bucketName);
-    await this.sleep(2e3);
-    await AliyunService.ensureCdnDomain(cdnDomain, bucketName);
-    await this.sleep(2e3);
-    await AliyunService.enableOssPrivateBucketOrigin(cdnDomain);
-    await this.sleep(2e3);
-    ui.success(`Enabled OSS private bucket origin for ${cdnDomain}`);
-    await AliyunService.setDefaultCacheRules(cdnDomain);
-    await this.sleep(2e3);
-    ui.success(`Set default cache rules for ${cdnDomain}`);
-    const cname = await AliyunService.getCdnCname(cdnDomain);
-    if (!cname) {
-      throw new Error(`No CNAME found for ${cdnDomain}. Try again in a minute.`);
-    }
-    ui.info(`CNAME for ${cdnDomain}:`, cname);
-    const existingCname = await AliyunService.getCnameRecordValue(
-      baseDomain,
-      dnsRr
-    );
-    if (existingCname) {
-      if (existingCname !== cname) {
-        throw new Error(
-          `Existing CNAME record for ${cdnDomain} points to ${existingCname}, not ${cname}.`
-        );
-      }
-      ui.success(`CNAME record already exists for ${cdnDomain}`);
-    } else {
-      await AliyunService.addRecord({
-        domainName: baseDomain,
-        rr: dnsRr,
-        type: "CNAME",
-        value: cname,
-        ttl: 600
-      });
-      await this.sleep(2e3);
-      ui.success(`Added CNAME record ${cdnDomain} -> ${cname}`);
-    }
-    if (!subdomain) {
-      const wwwCname = await AliyunService.getCnameRecordValue(
-        baseDomain,
-        "www"
-      );
-      if (wwwCname) {
-        if (wwwCname !== baseDomain) {
-          throw new Error(
-            `Existing CNAME record for www.${baseDomain} points to ${wwwCname}, not ${baseDomain}.`
-          );
-        }
-        ui.success(`CNAME record already exists for www.${baseDomain}`);
-      } else {
-        await AliyunService.addRecord({
-          domainName: baseDomain,
-          rr: "www",
-          type: "CNAME",
-          value: baseDomain,
-          ttl: 600
-        });
-        await this.sleep(2e3);
-        ui.success(`Added CNAME record www.${baseDomain} -> ${baseDomain}`);
-      }
-    }
-    await AliyunService.enableHttpsCertificate(cdnDomain);
-    await this.sleep(2e3);
-    ui.success(`Enabled HTTPS certificate for ${cdnDomain}`);
-    if (appConfig.type === "vite" && appConfig.routeType === "ssg") {
-      await AliyunService.enableSsgRewriteRule(cdnDomain);
-      await this.sleep(2e3);
-      ui.success(`Enabled SSG rewrite rule for ${cdnDomain}`);
-    } else {
-      await AliyunService.enableSpaRewriteRule(cdnDomain);
-      await this.sleep(2e3);
-      ui.success(`Enabled SPA rewrite rule for ${cdnDomain}`);
-    }
+    await setupStaticSiteBucket({
+      bucketName,
+      domainName: baseDomain,
+      subdomain: appConfig.subdomain,
+      routeType: appConfig.type === "vite" && appConfig.routeType === "ssg" ? "ssg" : "spa"
+    });
   }
   async initNode(appConfig, cwd) {
     console.log("Initializing node app...");
@@ -17194,7 +17219,7 @@ var LinearCommandHandler = class {
     for (let attempt = 0; attempt < 12; attempt++) {
       buffer = await this.captureClipboardImageAsPng();
       if (buffer.length > 0) break;
-      await sleep(150);
+      await sleep2(150);
     }
     if (buffer.length === 0) {
       const info = await this.getClipboardDebugInfo();
@@ -17645,7 +17670,7 @@ function parseJson(raw) {
     return JSON.parse(match[0]);
   }
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -17890,9 +17915,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path20, init) {
+  static async requestJson(path21, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path20}`, {
+    const response = await fetch(`${this.baseUrl}${path21}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -18940,9 +18965,406 @@ var AgentCommandHandler = class {
   }
 };
 
-// src/commands/AppCommandHandler.ts
+// src/commands/StoreCommandHandler.ts
 var import_node_fs13 = require("fs");
 var import_node_path18 = __toESM(require("path"));
+
+// src/storeClient.ts
+var STORE_LOG_VERSION = 1;
+var LOG_KIND_TABLE = 1e4;
+var LOG_KIND_MAPPING = 6003;
+function createHash3() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createDescriptor(input) {
+  for (const [label, value] of Object.entries({
+    chain: input.chain,
+    namespace: input.ns,
+    kind: input.kind,
+    name: input.name
+  })) {
+    if (!value || value.includes("/")) {
+      throw new Error(`Invalid ${label} "${value}". ${label} must be non-empty and cannot contain "/".`);
+    }
+  }
+  return { ...input };
+}
+function descriptorToTopic(descriptor) {
+  const normalized = createDescriptor(descriptor);
+  return `@${normalized.ns}/${normalized.name}`;
+}
+function descriptorPathSegments(descriptor) {
+  const normalized = createDescriptor(descriptor);
+  return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
+}
+function buildPathUrl(baseUrl, pathSegments, query) {
+  const path21 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path21, baseUrl);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function requestJson(url, init, fallbackMessage) {
+  const response = await fetch(url, init);
+  const payload = await response.json();
+  if (!response.ok || !payload?.success) {
+    throw new Error(payload?.message || `${fallbackMessage}: ${response.status}`);
+  }
+  return payload;
+}
+var IndexerClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async requestByPath(pathSegments, options = {}) {
+    const method = options.method ?? "GET";
+    const url = buildPathUrl(this.baseUrl, pathSegments, method === "GET" ? options.query : void 0);
+    const payload = await requestJson(
+      url,
+      {
+        method,
+        headers: {
+          Accept: "application/json",
+          ...method === "POST" ? { "Content-Type": "application/json" } : {}
+        },
+        ...method === "POST" ? { body: JSON.stringify(options.query ?? {}) } : {}
+      },
+      "Indexer request failed"
+    );
+    return payload.data;
+  }
+};
+var BlockLogAppender = class {
+  constructor(chainId, baseUrl) {
+    this.chainId = chainId;
+    this.baseUrl = baseUrl;
+  }
+  async append(logs) {
+    if (!logs.length) return;
+    const url = `${this.baseUrl.replace(/\/+$/, "")}/chains/${encodeURIComponent(this.chainId)}/logs`;
+    await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...process.env.TSDB_BEARER_TOKEN ? { authorization: `Bearer ${process.env.TSDB_BEARER_TOKEN}` } : {}
+      },
+      body: JSON.stringify({ logs })
+    }).then(async (response) => {
+      if (!response.ok) {
+        throw new Error(`TSDB request failed: ${response.status} ${response.statusText}`);
+      }
+    });
+  }
+};
+var Namespace = class {
+  constructor(options) {
+    this.options = options;
+    this.appender = new BlockLogAppender(options.chain, options.baseUrl.replace(/\/+$/, ""));
+    this.indexerClient = new IndexerClient(options.indexerBaseUrl.replace(/\/+$/, ""));
+  }
+  table(name) {
+    const descriptor = createDescriptor({
+      chain: this.options.chain,
+      ns: this.options.ns,
+      kind: "table",
+      name
+    });
+    return {
+      list: async (pageNo = 0) => {
+        const data = await this.indexerClient.requestByPath(
+          [...descriptorPathSegments(descriptor), "page"],
+          { query: { page_id: pageNo } }
+        );
+        if (!data) return [];
+        if (Array.isArray(data)) return data;
+        return Array.isArray(data.data) ? data.data : [];
+      },
+      getById: async (id) => {
+        const data = await this.indexerClient.requestByPath(
+          [...descriptorPathSegments(descriptor), "get_by_id"],
+          { query: { id } }
+        );
+        return data ?? void 0;
+      },
+      exists: async (id) => {
+        const data = await this.indexerClient.requestByPath(
+          [...descriptorPathSegments(descriptor), "exists"],
+          { query: { id } }
+        );
+        return Boolean(data);
+      },
+      appendRow: async (data) => {
+        const log = {
+          hash: createHash3(),
+          t: Date.now(),
+          kind: LOG_KIND_TABLE,
+          topic: descriptorToTopic(descriptor),
+          v: STORE_LOG_VERSION,
+          data: { type: "create", after: data }
+        };
+        await this.appender.append([log]);
+      },
+      updateRow: async (data) => {
+        const { id, ...value } = data;
+        const log = {
+          hash: createHash3(),
+          t: Date.now(),
+          kind: LOG_KIND_TABLE,
+          topic: descriptorToTopic(descriptor),
+          v: STORE_LOG_VERSION,
+          data: { type: "update", id, value }
+        };
+        await this.appender.append([log]);
+      },
+      deleteRow: async (id) => {
+        const log = {
+          hash: createHash3(),
+          t: Date.now(),
+          kind: LOG_KIND_TABLE,
+          topic: descriptorToTopic(descriptor),
+          v: STORE_LOG_VERSION,
+          data: { type: "delete", id }
+        };
+        await this.appender.append([log]);
+      }
+    };
+  }
+  kv(name) {
+    const descriptor = createDescriptor({
+      chain: this.options.chain,
+      ns: this.options.ns,
+      kind: "kv",
+      name
+    });
+    return {
+      list: async (pageNo = 0) => {
+        const data = await this.indexerClient.requestByPath([...descriptorPathSegments(descriptor), "page"], {
+          query: { page_id: pageNo }
+        });
+        if (!data) return [];
+        if (Array.isArray(data)) return data;
+        return Array.isArray(data.data) ? data.data : [];
+      },
+      get: async (key) => {
+        const data = await this.indexerClient.requestByPath(
+          [...descriptorPathSegments(descriptor), "get"],
+          { query: { key } }
+        );
+        return data ?? void 0;
+      },
+      exists: async (key) => {
+        const data = await this.indexerClient.requestByPath(
+          [...descriptorPathSegments(descriptor), "exists"],
+          { query: { key } }
+        );
+        return Boolean(data);
+      },
+      set: async (key, value) => {
+        const log = {
+          hash: createHash3(),
+          t: Date.now(),
+          kind: LOG_KIND_MAPPING,
+          topic: descriptorToTopic(descriptor),
+          v: STORE_LOG_VERSION,
+          data: { key, value }
+        };
+        await this.appender.append([log]);
+      },
+      delete: async (key) => {
+        const log = {
+          hash: createHash3(),
+          t: Date.now(),
+          kind: LOG_KIND_MAPPING,
+          topic: descriptorToTopic(descriptor),
+          v: STORE_LOG_VERSION,
+          data: { key, value: null }
+        };
+        await this.appender.append([log]);
+      }
+    };
+  }
+};
+
+// src/commands/StoreCommandHandler.ts
+var StoreCommandHandler = class {
+  async handle(args) {
+    if (args.scope === "namespace") {
+      const items = await this.listNamespaces(args);
+      this.renderNamespaceList(items, args.json);
+      return;
+    }
+    const namespace = this.createNamespace(args);
+    if (args.scope === "table") {
+      const table = namespace.table(args.name);
+      switch (args.action) {
+        case "list": {
+          const rows = await table.list(args.page);
+          this.renderJsonOrSummary(
+            rows,
+            args.json,
+            "No rows found.",
+            (row) => row.id ?? "<missing-id>"
+          );
+          return;
+        }
+        case "get": {
+          const row = await table.getById(args.id);
+          this.renderValue(row, args.json);
+          return;
+        }
+        case "exists": {
+          const exists = await table.exists(args.id);
+          this.renderValue(exists, args.json);
+          return;
+        }
+        case "delete": {
+          await table.deleteRow(args.id);
+          ui.success(`Deleted row ${args.name}/${args.id}`);
+          return;
+        }
+        case "create": {
+          const payload = this.readJsonFile(args.filePath);
+          await table.appendRow(payload);
+          ui.success(`Created row in ${args.name}`, { filePath: args.filePath });
+          return;
+        }
+        case "update": {
+          const payload = this.readJsonFile(args.filePath);
+          await table.updateRow(payload);
+          ui.success(`Updated row in ${args.name}`, { filePath: args.filePath });
+          return;
+        }
+      }
+    }
+    const kv = namespace.kv(args.name);
+    switch (args.action) {
+      case "list": {
+        const rows = await kv.list(args.page);
+        this.renderJsonOrSummary(
+          rows,
+          args.json,
+          "No kv entries found.",
+          (row) => row.key
+        );
+        return;
+      }
+      case "get": {
+        const value = await kv.get(args.key);
+        this.renderValue(value, args.json);
+        return;
+      }
+      case "exists": {
+        const exists = await kv.exists(args.key);
+        this.renderValue(exists, args.json);
+        return;
+      }
+      case "delete": {
+        await kv.delete(args.key);
+        ui.success(`Deleted key ${args.name}/${args.key}`);
+        return;
+      }
+      case "set": {
+        const value = args.filePath ? this.readJsonFile(args.filePath) : JSON.parse(args.value);
+        await kv.set(args.key, value);
+        ui.success(`Set key ${args.name}/${args.key}`);
+        return;
+      }
+    }
+  }
+  createNamespace(args) {
+    return new Namespace({
+      chain: args.chain,
+      ns: args.namespace,
+      baseUrl: this.resolveBaseUrl(args.baseUrl),
+      indexerBaseUrl: this.resolveIndexerBaseUrl(args.indexerBaseUrl)
+    });
+  }
+  resolveBaseUrl(baseUrl) {
+    const resolved = baseUrl || process.env.PMATE_STORE_BASE_URL || process.env.BLOCKCHAIN_BASE_URL;
+    if (!resolved) {
+      throw new Error(
+        "Missing store base URL. Provide --base-url or set PMATE_STORE_BASE_URL / BLOCKCHAIN_BASE_URL."
+      );
+    }
+    return resolved.replace(/\/+$/, "");
+  }
+  resolveIndexerBaseUrl(indexerBaseUrl) {
+    return (indexerBaseUrl || process.env.PMATE_STORE_INDEXER_BASE_URL || process.env.INDEXER_BASE_URL || "https://indexer.pmate.chat").replace(/\/+$/, "");
+  }
+  async listNamespaces(args) {
+    const baseUrl = this.resolveIndexerBaseUrl(args.indexerBaseUrl);
+    const url = new URL(`/chains/${encodeURIComponent(args.chain)}/namespaces`, `${baseUrl}/`);
+    const response = await fetch(url.toString(), {
+      headers: { Accept: "application/json" }
+    });
+    const payload = await response.json();
+    if (!response.ok || !payload?.success) {
+      throw new Error(payload?.message || `Namespace list request failed with status ${response.status}`);
+    }
+    return payload.data ?? [];
+  }
+  readJsonFile(filePath) {
+    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_fs13.readFileSync)(absolutePath, "utf8");
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid JSON in ${absolutePath}: ${message}`);
+    }
+  }
+  renderNamespaceList(items, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(items, null, 2));
+      return;
+    }
+    if (items.length === 0) {
+      ui.warn("No namespaces found.");
+      return;
+    }
+    for (const item of items) {
+      ui.info(`${item.chain}/${item.namespace}`);
+    }
+  }
+  renderJsonOrSummary(items, asJson, emptyText, label) {
+    if (asJson) {
+      ui.plain(JSON.stringify(items, null, 2));
+      return;
+    }
+    if (items.length === 0) {
+      ui.warn(emptyText);
+      return;
+    }
+    for (const item of items) {
+      ui.info(label(item), item);
+    }
+  }
+  renderValue(value, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(value ?? null, null, 2));
+      return;
+    }
+    if (typeof value === "boolean") {
+      ui.plain(String(value));
+      return;
+    }
+    if (value == null) {
+      ui.warn("Not found.");
+      return;
+    }
+    ui.plain(JSON.stringify(value, null, 2));
+  }
+};
+
+// src/commands/AppCommandHandler.ts
+var import_node_fs14 = require("fs");
+var import_node_path19 = __toESM(require("path"));
 init_sessionStore();
 var AppCommandHandler = class {
   async handle(args) {
@@ -19017,11 +19439,11 @@ var AppCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19189,7 +19611,7 @@ function parseAgentArgs(tokens) {
   }
   let baseUrl;
   let json = false;
-  const takeSharedOptions = () => {
+  const takeSharedOptions2 = () => {
     while (rest.length > 0) {
       const token = rest[0];
       if (token === "--base-url") {
@@ -19206,7 +19628,7 @@ function parseAgentArgs(tokens) {
     }
   };
   if (action === "namespaces") {
-    takeSharedOptions();
+    takeSharedOptions2();
     if (rest.length > 0) {
       throw new Error(`Unknown agent namespaces option: ${rest[0]}`);
     }
@@ -19248,7 +19670,7 @@ function parseAgentArgs(tokens) {
         `Usage: agent ${action} [<namespace>] <name> [--base-url <url>] [--json]`
       );
     }
-    takeSharedOptions();
+    takeSharedOptions2();
     if (rest.length > 0) {
       throw new Error(`Unknown agent ${action} option: ${rest[0]}`);
     }
@@ -19329,6 +19751,213 @@ function requireValue(tokens, optionName) {
   return value;
 }
 
+// src/storeCommandParser.ts
+var DEFAULT_CHAIN = "pmate";
+var DEFAULT_NAMESPACE2 = "pmate";
+function parseStoreArgs(tokens) {
+  const rest = [...tokens];
+  const scope = rest.shift();
+  if (!scope) {
+    throw new Error("Missing store scope. Use: store namespace|table|kv");
+  }
+  const action = rest.shift();
+  if (!action) {
+    throw new Error(`Missing store ${scope} action.`);
+  }
+  const shared = {
+    chain: DEFAULT_CHAIN,
+    namespace: DEFAULT_NAMESPACE2,
+    baseUrl: void 0,
+    indexerBaseUrl: void 0,
+    json: false
+  };
+  if (scope === "namespace") {
+    if (action !== "list") {
+      throw new Error(`Unknown store namespace action: ${action}`);
+    }
+    takeSharedOptions(rest, shared);
+    if (rest.length > 0) {
+      throw new Error(`Unknown store namespace option: ${rest[0]}`);
+    }
+    return {
+      type: "store" /* Store */,
+      scope,
+      action,
+      ...shared
+    };
+  }
+  if (scope === "table") {
+    return parseTableArgs(action, rest, shared);
+  }
+  if (scope === "kv") {
+    return parseKvArgs(action, rest, shared);
+  }
+  throw new Error(`Unknown store scope: ${scope}`);
+}
+function parseTableArgs(action, rest, shared) {
+  const name = rest.shift();
+  if (!name || name.startsWith("-")) {
+    throw new Error(`Missing table name. Usage: store table ${action} <name> ...`);
+  }
+  if (action === "list") {
+    let page = 0;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--page":
+          page = parsePage(requireValue2(rest, token));
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    return { type: "store" /* Store */, scope: "table", action, name, page, ...shared };
+  }
+  if (action === "get" || action === "exists" || action === "delete") {
+    let id;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--id":
+          id = requireValue2(rest, token);
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    if (!id) {
+      throw new Error(`Missing required option --id for store table ${action}`);
+    }
+    return { type: "store" /* Store */, scope: "table", action, name, id, ...shared };
+  }
+  if (action === "create" || action === "update") {
+    let filePath;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--file":
+          filePath = requireValue2(rest, token);
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    if (!filePath) {
+      throw new Error(`Missing required option --file for store table ${action}`);
+    }
+    return { type: "store" /* Store */, scope: "table", action, name, filePath, ...shared };
+  }
+  throw new Error(`Unknown store table action: ${action}`);
+}
+function parseKvArgs(action, rest, shared) {
+  const name = rest.shift();
+  if (!name || name.startsWith("-")) {
+    throw new Error(`Missing kv name. Usage: store kv ${action} <name> ...`);
+  }
+  if (action === "list") {
+    let page = 0;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--page":
+          page = parsePage(requireValue2(rest, token));
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    return { type: "store" /* Store */, scope: "kv", action, name, page, ...shared };
+  }
+  if (action === "get" || action === "exists" || action === "delete") {
+    let key;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--key":
+          key = requireValue2(rest, token);
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    if (!key) {
+      throw new Error(`Missing required option --key for store kv ${action}`);
+    }
+    return { type: "store" /* Store */, scope: "kv", action, name, key, ...shared };
+  }
+  if (action === "set") {
+    let key;
+    let value;
+    let filePath;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--key":
+          key = requireValue2(rest, token);
+          break;
+        case "--value":
+          value = requireValue2(rest, token);
+          break;
+        case "--file":
+          filePath = requireValue2(rest, token);
+          break;
+        default:
+          pushSharedOption(token, rest, shared);
+      }
+    }
+    if (!key) {
+      throw new Error("Missing required option --key for store kv set");
+    }
+    if (!value && !filePath || value && filePath) {
+      throw new Error("Provide exactly one of --value or --file for store kv set");
+    }
+    return { type: "store" /* Store */, scope: "kv", action, name, key, value, filePath, ...shared };
+  }
+  throw new Error(`Unknown store kv action: ${action}`);
+}
+function takeSharedOptions(rest, shared) {
+  while (rest.length > 0) {
+    const token = rest.shift();
+    pushSharedOption(token, rest, shared);
+  }
+}
+function pushSharedOption(token, rest, shared) {
+  switch (token) {
+    case "--chain":
+      shared.chain = requireValue2(rest, token);
+      break;
+    case "--ns":
+    case "--namespace":
+      shared.namespace = requireValue2(rest, token);
+      break;
+    case "--base-url":
+      shared.baseUrl = requireValue2(rest, token);
+      break;
+    case "--indexer-base-url":
+      shared.indexerBaseUrl = requireValue2(rest, token);
+      break;
+    case "--json":
+      shared.json = true;
+      break;
+    default:
+      throw new Error(`Unknown store option: ${token}`);
+  }
+}
+function requireValue2(tokens, optionName) {
+  const value = tokens.shift();
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${optionName}`);
+  }
+  return value;
+}
+function parsePage(value) {
+  const page = Number.parseInt(value, 10);
+  if (!Number.isInteger(page) || page < 0) {
+    throw new Error(`Invalid --page value: ${value}`);
+  }
+  return page;
+}
+
 // src/appCommandParser.ts
 function parseAppArgs(tokens) {
   const rest = [...tokens];
@@ -19338,12 +19967,12 @@ function parseAppArgs(tokens) {
   }
   let baseUrl;
   let json = false;
-  const takeSharedOptions = () => {
+  const takeSharedOptions2 = () => {
     while (rest.length > 0) {
       const token = rest[0];
       if (token === "--base-url") {
         rest.shift();
-        baseUrl = requireValue2(rest, token);
+        baseUrl = requireValue3(rest, token);
         continue;
       }
       if (token === "--json") {
@@ -19355,7 +19984,7 @@ function parseAppArgs(tokens) {
     }
   };
   if (action === "list") {
-    takeSharedOptions();
+    takeSharedOptions2();
     if (rest.length > 0) {
       throw new Error(`Unknown app list option: ${rest[0]}`);
     }
@@ -19368,7 +19997,7 @@ function parseAppArgs(tokens) {
         `Usage: app ${action} <id> [--base-url <url>] [--json]`
       );
     }
-    takeSharedOptions();
+    takeSharedOptions2();
     if (rest.length > 0) {
       throw new Error(`Unknown app ${action} option: ${rest[0]}`);
     }
@@ -19380,10 +20009,10 @@ function parseAppArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--file":
-          filePath = requireValue2(rest, token);
+          filePath = requireValue3(rest, token);
           break;
         case "--base-url":
-          baseUrl = requireValue2(rest, token);
+          baseUrl = requireValue3(rest, token);
           break;
         case "--json":
           json = true;
@@ -19409,10 +20038,10 @@ function parseAppArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--file":
-          filePath = requireValue2(rest, token);
+          filePath = requireValue3(rest, token);
           break;
         case "--base-url":
-          baseUrl = requireValue2(rest, token);
+          baseUrl = requireValue3(rest, token);
           break;
         case "--json":
           json = true;
@@ -19428,7 +20057,7 @@ function parseAppArgs(tokens) {
   }
   throw new Error(`Unknown app action: ${action}`);
 }
-function requireValue2(tokens, optionName) {
+function requireValue3(tokens, optionName) {
   const value = tokens.shift();
   if (!value || value.startsWith("-")) {
     throw new Error(`Missing value for ${optionName}`);
@@ -19438,7 +20067,7 @@ function requireValue2(tokens, optionName) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs14.readFileSync)(import_node_path19.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs15.readFileSync)(import_node_path20.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk3.default.bold(`pmate v${pkg.version}`),
@@ -19459,7 +20088,7 @@ var HELP_TEXT = [
   `  ${import_chalk3.default.gray("                  --type <t> --value <v> --rr <rr> [--ttl <n>] [--domain <name>]")}`,
   `  ${import_chalk3.default.cyan("sts")}              Request an OSS STS token from the CI server`,
   `  ${import_chalk3.default.cyan("bucket")}           Manage OSS buckets`,
-  `  ${import_chalk3.default.gray("                  --create --name <bucket>")}`,
+  `  ${import_chalk3.default.gray("                  --create --name <bucket> [--subdomain <name> --domain <name>]")}`,
   `  ${import_chalk3.default.cyan("deploy")}           Deploy or view logs for app dir from .pmate.yaml`,
   `  ${import_chalk3.default.gray("                  <app-name> [deploy|logs] [--cwd <dir>]")}`,
   `  ${import_chalk3.default.cyan("log")}              Query app logs from the log indexer API`,
@@ -19522,6 +20151,11 @@ var HELP_TEXT = [
   `  ${import_chalk3.default.gray("                  update [<namespace>] <name> --file <path> [--base-url <url>] [--json]")}`,
   `  ${import_chalk3.default.gray("                  delete [<namespace>] <name> [--base-url <url>] [--json]")}`,
   `  ${import_chalk3.default.gray("                  default namespace: pmate; default base URL: https://agent-api.pmate.chat")}`,
+  `  ${import_chalk3.default.cyan("store")}            Manage @pmate/store namespaces, tables, and kv stores`,
+  `  ${import_chalk3.default.gray("                  namespace list [--chain <chain>] [--indexer-base-url <url>] [--json]")}`,
+  `  ${import_chalk3.default.gray("                  table list|get|exists|create|update|delete <name> [options]")}`,
+  `  ${import_chalk3.default.gray("                  kv list|get|exists|set|delete <name> [options]")}`,
+  `  ${import_chalk3.default.gray("                  defaults: chain=pmate namespace=pmate env base URLs from BLOCKCHAIN_BASE_URL / INDEXER_BASE_URL")}`,
   `  ${import_chalk3.default.cyan("app")}              Manage app registry entries via apps-api`,
   `  ${import_chalk3.default.gray("                  list [--base-url <url>] [--json]")}`,
   `  ${import_chalk3.default.gray("                  get <id> [--base-url <url>] [--json]")}`,
@@ -19589,7 +20223,7 @@ function parseCommandArgs(args) {
       const token = rest.shift();
       switch (token) {
         case "--app":
-          app = requireValue3(rest, token);
+          app = requireValue4(rest, token);
           break;
         default:
           throw new Error(`Unknown login option: ${token}`);
@@ -19654,6 +20288,9 @@ function parseCommandArgs(args) {
   if (args.rest[0] === "agent") {
     return parseAgentArgs(args.rest.slice(1));
   }
+  if (args.rest[0] === "store") {
+    return parseStoreArgs(args.rest.slice(1));
+  }
   if (args.rest[0] === "app") {
     return parseAppArgs(args.rest.slice(1));
   }
@@ -19674,7 +20311,7 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue3(rest, token);
+          scope = requireValue4(rest, token);
           break;
         default:
           throw new Error(`Unknown vercel option: ${token}`);
@@ -19694,10 +20331,10 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue3(rest, token);
+          scope = requireValue4(rest, token);
           break;
         case "--project":
-          project = requireValue3(rest, token);
+          project = requireValue4(rest, token);
           break;
         case "--last-week":
           lastWeek = true;
@@ -19728,16 +20365,16 @@ function parseAddDnsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--type":
-        options.dnsType = requireValue3(rest, token);
+        options.dnsType = requireValue4(rest, token);
         break;
       case "--value":
-        options.dnsValue = requireValue3(rest, token);
+        options.dnsValue = requireValue4(rest, token);
         break;
       case "--rr":
-        options.dnsRr = requireValue3(rest, token);
+        options.dnsRr = requireValue4(rest, token);
         break;
       case "--ttl": {
-        const ttlValue = requireValue3(rest, token);
+        const ttlValue = requireValue4(rest, token);
         const ttl = Number.parseInt(ttlValue, 10);
         if (!Number.isFinite(ttl) || ttl <= 0) {
           throw new Error(`Invalid --ttl value: ${ttlValue}`);
@@ -19746,7 +20383,7 @@ function parseAddDnsArgs(tokens) {
         break;
       }
       case "--domain":
-        options.dnsDomain = requireValue3(rest, token);
+        options.dnsDomain = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown add-dns option: ${token}`);
@@ -19767,7 +20404,9 @@ function parseAddDnsArgs(tokens) {
 function parseBucketArgs(tokens) {
   const options = {
     bucketCreate: false,
-    bucketName: ""
+    bucketName: "",
+    bucketSubdomain: void 0,
+    bucketDomain: void 0
   };
   const rest = [...tokens];
   while (rest.length > 0) {
@@ -19777,7 +20416,13 @@ function parseBucketArgs(tokens) {
         options.bucketCreate = true;
         break;
       case "--name":
-        options.bucketName = requireValue3(rest, token);
+        options.bucketName = requireValue4(rest, token);
+        break;
+      case "--subdomain":
+        options.bucketSubdomain = requireValue4(rest, token);
+        break;
+      case "--domain":
+        options.bucketDomain = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown bucket option: ${token}`);
@@ -19789,6 +20434,9 @@ function parseBucketArgs(tokens) {
   if (!options.bucketName.trim()) {
     throw new Error("Missing bucket name. Use --name <bucket>.");
   }
+  if (options.bucketSubdomain && !options.bucketDomain?.trim()) {
+    throw new Error("Missing domain name. Use --domain <name> when --subdomain is set.");
+  }
   return { type: "bucket" /* Bucket */, ...options };
 }
 function parseDeployArgs(tokens) {
@@ -19813,7 +20461,7 @@ function parseDeployArgs(tokens) {
         options.deployAction = "logs";
         break;
       case "--cwd":
-        options.deployCwd = requireValue3(rest, token);
+        options.deployCwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown deploy option: ${token}`);
@@ -19838,13 +20486,13 @@ function parseLogArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.logCwd = requireValue3(rest, token);
+        options.logCwd = requireValue4(rest, token);
         break;
       case "--ns":
-        options.logNamespace = requireValue3(rest, token);
+        options.logNamespace = requireValue4(rest, token);
         break;
       case "--page": {
-        const value = requireValue3(rest, token);
+        const value = requireValue4(rest, token);
         const page = Number.parseInt(value, 10);
         if (!Number.isFinite(page) || page < 0) {
           throw new Error(`Invalid log page: ${value}`);
@@ -19856,7 +20504,7 @@ function parseLogArgs(tokens) {
         options.logHistory = true;
         break;
       case "--search":
-        options.logSearch = requireValue3(rest, token);
+        options.logSearch = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown log option: ${token}`);
@@ -19879,7 +20527,7 @@ function parseInitArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.initCwd = requireValue3(rest, token);
+        options.initCwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown init option: ${token}`);
@@ -19902,7 +20550,7 @@ function parseDevArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.devCwd = requireValue3(rest, token);
+        options.devCwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown dev option: ${token}`);
@@ -19932,13 +20580,13 @@ function parseOssArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--bucket":
-        bucket = requireValue3(rest, token);
+        bucket = requireValue4(rest, token);
         break;
       case "--file":
-        filePath = requireValue3(rest, token);
+        filePath = requireValue4(rest, token);
         break;
       case "--key":
-        objectKey = requireValue3(rest, token);
+        objectKey = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown oss option: ${token}`);
@@ -19971,7 +20619,7 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "set";
-        key = requireValue3(rest, token);
+        key = requireValue4(rest, token);
         break;
       case "--list":
         if (action) {
@@ -19984,17 +20632,17 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "delete";
-        key = requireValue3(rest, token);
+        key = requireValue4(rest, token);
         break;
       case "--value":
-        value = requireValue3(rest, token);
+        value = requireValue4(rest, token);
         break;
       case "--verbose":
       case "-v":
         verbose = true;
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown env option: ${token}`);
@@ -20052,7 +20700,7 @@ function parseCommitArgs(tokens) {
         push = true;
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown commit option: ${token}`);
@@ -20068,10 +20716,10 @@ function parseSummaryArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--pr":
-        prRef = requireValue3(rest, token);
+        prRef = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown summary option: ${token}`);
@@ -20140,10 +20788,10 @@ function parseLinearPrArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20172,35 +20820,35 @@ function parseLinearCreateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--repl":
         useRepl = true;
         break;
       case "--title":
-        title = requireValue3(rest, token);
+        title = requireValue4(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue3(rest, token));
+        description = decodeEscapedNewlines(requireValue4(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue3(rest, token);
+        teamId = requireValue4(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue3(rest, token);
+        teamKey = requireValue4(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue3(rest, token));
+        priority = parseLinearPriority(requireValue4(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue3(rest, token);
+        parentId = requireValue4(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue3(rest, token);
+        stateId = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20235,10 +20883,10 @@ function parseLinearWhoamiArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20263,10 +20911,10 @@ function parseLinearViewArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20301,32 +20949,32 @@ function parseLinearUpdateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--title":
-        title = requireValue3(rest, token);
+        title = requireValue4(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue3(rest, token));
+        description = decodeEscapedNewlines(requireValue4(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue3(rest, token);
+        teamId = requireValue4(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue3(rest, token);
+        teamKey = requireValue4(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue3(rest, token));
+        priority = parseLinearPriority(requireValue4(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue3(rest, token);
+        parentId = requireValue4(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue3(rest, token);
+        stateId = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20364,10 +21012,10 @@ function parseLinearSubIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20394,15 +21042,15 @@ function parseLinearCommentArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--body":
       case "--desc":
       case "--description":
-        body = decodeEscapedNewlines(requireValue3(rest, token));
+        body = decodeEscapedNewlines(requireValue4(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20432,10 +21080,10 @@ function parseLinearCommentsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20459,16 +21107,16 @@ function parseLinearCycleArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue3(rest, token);
+        teamId = requireValue4(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue3(rest, token);
+        teamKey = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20491,10 +21139,10 @@ function parseLinearTeamsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20521,16 +21169,16 @@ function parseLinearUserIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue3(rest, token));
+        cycle = parseLinearCycle(requireValue4(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue3(rest, token));
+        status = parseLinearStatus(requireValue4(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20564,28 +21212,28 @@ function parseLinearIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue3(rest, token);
+        teamId = requireValue4(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue3(rest, token);
+        teamKey = requireValue4(rest, token);
         break;
       case "--user":
-        user = requireValue3(rest, token);
+        user = requireValue4(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue3(rest, token));
+        cycle = parseLinearCycle(requireValue4(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue3(rest, token));
+        status = parseLinearStatus(requireValue4(rest, token));
         break;
       case "--query":
-        query = requireValue3(rest, token).trim();
+        query = requireValue4(rest, token).trim();
         break;
       case "--limit": {
-        const value = Number.parseInt(requireValue3(rest, token), 10);
+        const value = Number.parseInt(requireValue4(rest, token), 10);
         if (!Number.isInteger(value) || value < 1 || value > 250) {
           throw new Error("Invalid --limit. Expected an integer between 1 and 250.");
         }
@@ -20593,7 +21241,7 @@ function parseLinearIssuesArgs(tokens) {
         break;
       }
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20634,10 +21282,10 @@ function parseLinearLegacyArgs(tokens) {
         useScreenshot = true;
         break;
       case "--account":
-        account = requireValue3(rest, token);
+        account = requireValue4(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue3(rest, token);
+        cwd = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20731,19 +21379,19 @@ function parseNotionArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--parent":
-          parentPageId = requireValue3(rest, token);
+          parentPageId = requireValue4(rest, token);
           break;
         case "--title":
-          title = requireValue3(rest, token);
+          title = requireValue4(rest, token);
           break;
         case "--private":
           isPrivate = true;
           break;
         case "--content":
-          content2 = requireValue3(rest, token);
+          content2 = requireValue4(rest, token);
           break;
         case "--file":
-          filePath2 = requireValue3(rest, token);
+          filePath2 = requireValue4(rest, token);
           break;
         default:
           throw new Error(`Unknown notion option: ${token}`);
@@ -20787,10 +21435,10 @@ function parseNotionArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--content":
-        content = requireValue3(rest, token);
+        content = requireValue4(rest, token);
         break;
       case "--file":
-        filePath = requireValue3(rest, token);
+        filePath = requireValue4(rest, token);
         break;
       case "--append":
         append = true;
@@ -20835,11 +21483,11 @@ function parseRandomArgs(tokens) {
         mode = "easy";
         break;
       case "--length":
-        length = parsePositiveInt(requireValue3(rest, token), token);
+        length = parsePositiveInt(requireValue4(rest, token), token);
         seenLength = true;
         break;
       case "--charset": {
-        const value = requireValue3(rest, token);
+        const value = requireValue4(rest, token);
         if (!["base64url", "hex", "alnum", "ascii"].includes(value)) {
           throw new Error(
             `Invalid --charset value: ${value}. Use base64url|hex|alnum|ascii.`
@@ -20850,18 +21498,18 @@ function parseRandomArgs(tokens) {
         break;
       }
       case "--count":
-        count = parsePositiveInt(requireValue3(rest, token), token);
+        count = parsePositiveInt(requireValue4(rest, token), token);
         break;
       case "--words":
-        words = parsePositiveInt(requireValue3(rest, token), token);
+        words = parsePositiveInt(requireValue4(rest, token), token);
         seenWords = true;
         break;
       case "--digits":
-        digits = parseNonNegativeInt(requireValue3(rest, token), token);
+        digits = parseNonNegativeInt(requireValue4(rest, token), token);
         seenDigits = true;
         break;
       case "--separator":
-        separator = requireValue3(rest, token);
+        separator = requireValue4(rest, token);
         seenSeparator = true;
         break;
       default:
@@ -20904,7 +21552,7 @@ function parseCollectArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--endpoint":
-        options.endpoint = requireValue3(rest, token);
+        options.endpoint = requireValue4(rest, token);
         break;
       case "--json":
         options.json = true;
@@ -20914,7 +21562,7 @@ function parseCollectArgs(tokens) {
         break;
       case "--thread":
         options.mode = "thread";
-        options.threadName = requireValue3(rest, token);
+        options.threadName = requireValue4(rest, token);
         break;
       default:
         throw new Error(`Unknown collect option: ${token}`);
@@ -20925,7 +21573,7 @@ function parseCollectArgs(tokens) {
   }
   return { type: "collect" /* Collect */, ...options };
 }
-function requireValue3(tokens, optionName) {
+function requireValue4(tokens, optionName) {
   const value = tokens.shift();
   if (!value) {
     throw new Error(`Missing value for ${optionName}`);
@@ -21066,6 +21714,11 @@ async function main() {
         await handler.handle(commandArgs);
         return;
       }
+      case "store" /* Store */: {
+        const handler = new StoreCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
       case "app" /* App */: {
         const handler = new AppCommandHandler();
         await handler.handle(commandArgs);