@pmate/cli 0.15.0 → 0.16.1

package/dist/index.js

@@ -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));
 }
 
@@ -18782,167 +18807,6 @@ function parseMessageText(raw) {
 var import_node_fs12 = require("fs");
 var import_node_path17 = __toESM(require("path"));
 init_sessionStore();
-var AgentCommandHandler = class {
-  async handle(args) {
-    const token = this.readToken();
-    const baseUrl = this.resolveBaseUrl(args.baseUrl);
-    switch (args.action) {
-      case "namespaces": {
-        const response = await this.request(
-          baseUrl,
-          token,
-          "GET",
-          "/agents/namespaces"
-        );
-        this.renderNamespaces(response.items, args.json);
-        return;
-      }
-      case "list": {
-        const response = await this.request(
-          baseUrl,
-          token,
-          "GET",
-          `/agents?namespace=${encodeURIComponent(args.namespace)}`
-        );
-        this.renderList(response.items, args.json);
-        return;
-      }
-      case "get": {
-        const record = await this.request(
-          baseUrl,
-          token,
-          "GET",
-          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`
-        );
-        this.renderJson(record, args.json ?? true);
-        return;
-      }
-      case "create": {
-        const payload = this.readJsonFile(args.filePath);
-        const record = await this.request(
-          baseUrl,
-          token,
-          "POST",
-          `/agents/${encodeURIComponent(args.namespace)}`,
-          payload
-        );
-        ui.success(`Created agent ${record.id}`);
-        this.renderJson(record, args.json);
-        return;
-      }
-      case "update": {
-        const payload = this.readJsonFile(args.filePath);
-        const record = await this.request(
-          baseUrl,
-          token,
-          "PUT",
-          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`,
-          payload
-        );
-        ui.success(`Updated agent ${record.id}`);
-        this.renderJson(record, args.json);
-        return;
-      }
-      case "delete": {
-        const record = await this.request(
-          baseUrl,
-          token,
-          "DELETE",
-          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`
-        );
-        ui.success(`Disabled agent ${record.id}`);
-        this.renderJson(record, args.json);
-        return;
-      }
-    }
-  }
-  resolveBaseUrl(baseUrl) {
-    return (baseUrl || process.env.PMATE_AGENT_API_BASE_URL || "https://agent-api.pmate.chat").replace(
-      /\/+$/,
-      ""
-    );
-  }
-  readToken() {
-    return readRequiredSession({
-      preferredApp: DEFAULT_APP_ID
-    }).token;
-  }
-  readJsonFile(filePath) {
-    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
-      throw new Error(`JSON file not found: ${absolutePath}`);
-    }
-    const raw = (0, import_node_fs12.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}`);
-    }
-  }
-  async request(baseUrl, token, method, pathname, body) {
-    const response = await fetch(`${baseUrl}${pathname}`, {
-      method,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    });
-    let payload = null;
-    try {
-      payload = await response.json();
-    } catch {
-      payload = null;
-    }
-    if (!response.ok || !payload?.success) {
-      throw new Error(payload?.message || `Request failed with status ${response.status}`);
-    }
-    return payload.data;
-  }
-  renderList(items, asJson) {
-    if (asJson) {
-      ui.plain(JSON.stringify(items, null, 2));
-      return;
-    }
-    if (items.length === 0) {
-      ui.warn("No agents found.");
-      return;
-    }
-    for (const item of items) {
-      ui.info(`${item.namespace}/${item.name}`, {
-        status: item.status,
-        version: item.version
-      });
-    }
-  }
-  renderJson(value, asJson) {
-    if (!asJson) {
-      return;
-    }
-    ui.plain(JSON.stringify(value, null, 2));
-  }
-  renderNamespaces(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.namespace, {
-        status: item.status,
-        updatedAt: item.updatedAt
-      });
-    }
-  }
-};
-
-// 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;
@@ -18990,6 +18854,13 @@ async function requestJson(url, init, fallbackMessage) {
   }
   return payload;
 }
+function normalizeNamespace(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(normalized)) {
+    throw new Error("Invalid namespace. Use lowercase letters, numbers, and dashes only.");
+  }
+  return normalized;
+}
 var IndexerClient = class {
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
@@ -19162,33 +19033,348 @@ var Namespace = class {
     };
   }
 };
-
-// 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;
+var NamespaceRegistry = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async list() {
+    return this.request("GET", "/namespaces");
+  }
+  async get(namespace) {
+    const normalized = normalizeNamespace(namespace);
+    const response = await fetch(
+      `${this.options.registryBaseUrl.replace(/\/+$/, "")}/namespaces/${encodeURIComponent(normalized)}`,
+      {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          ...this.options.headers
+        }
+      }
+    );
+    if (response.status === 404) {
+      return void 0;
+    }
+    const payload = await response.json();
+    if (!response.ok || !payload?.success) {
+      throw new Error(payload?.message || `Namespace request failed: ${response.status}`);
+    }
+    return payload.data;
+  }
+  async exists(namespace) {
+    return Boolean(await this.get(namespace));
+  }
+  async create(namespace) {
+    return this.request("POST", "/namespaces", {
+      namespace: normalizeNamespace(namespace)
+    });
+  }
+  async require(namespace) {
+    const record = await this.get(namespace);
+    if (!record || record.status !== "active") {
+      throw new Error(`Namespace "${normalizeNamespace(namespace)}" is not registered.`);
+    }
+    if (!this.options.blockchainBaseUrl || !this.options.indexerBaseUrl) {
+      throw new Error("Namespace handle requires blockchain and indexer base URLs.");
+    }
+    return new Namespace({
+      chain: this.options.chain,
+      ns: record.namespace,
+      baseUrl: this.options.blockchainBaseUrl,
+      indexerBaseUrl: this.options.indexerBaseUrl
+    });
+  }
+  async request(method, pathname, body) {
+    const response = await fetch(`${this.options.registryBaseUrl.replace(/\/+$/, "")}${pathname}`, {
+      method,
+      headers: {
+        Accept: "application/json",
+        ...this.options.headers,
+        ...method === "POST" ? { "Content-Type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    const payload = await response.json();
+    if (!response.ok || !payload?.success) {
+      throw new Error(payload?.message || `Namespace request failed: ${response.status}`);
+    }
+    return payload.data;
+  }
+};
+
+// src/commands/AgentCommandHandler.ts
+var AgentCommandHandler = class {
+  async handle(args) {
+    const token = this.readToken();
+    const baseUrl = this.resolveBaseUrl(args.baseUrl);
+    switch (args.action) {
+      case "namespaces": {
+        const response = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          "/agents/namespaces"
+        );
+        this.renderNamespaces(response.items, args.json);
+        return;
+      }
+      case "list": {
+        const response = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          `/agents?namespace=${encodeURIComponent(args.namespace)}`
+        );
+        this.renderList(response.items, args.json);
+        return;
+      }
+      case "get": {
+        const record = await this.request(
+          baseUrl,
+          token,
+          "GET",
+          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`
+        );
+        this.renderJson(record, args.json ?? true);
+        return;
+      }
+      case "create": {
+        await this.requireNamespace(args.namespace, baseUrl);
+        const payload = this.readJsonFile(args.filePath);
+        const record = await this.request(
+          baseUrl,
+          token,
+          "POST",
+          `/agents/${encodeURIComponent(args.namespace)}`,
+          payload
+        );
+        ui.success(`Created agent ${record.id}`);
+        this.renderJson(record, args.json);
+        return;
+      }
+      case "update": {
+        const payload = this.readJsonFile(args.filePath);
+        const record = await this.request(
+          baseUrl,
+          token,
+          "PUT",
+          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`,
+          payload
+        );
+        ui.success(`Updated agent ${record.id}`);
+        this.renderJson(record, args.json);
+        return;
+      }
+      case "delete": {
+        const record = await this.request(
+          baseUrl,
+          token,
+          "DELETE",
+          `/agents/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.name)}`
+        );
+        ui.success(`Disabled agent ${record.id}`);
+        this.renderJson(record, args.json);
+        return;
+      }
+    }
+  }
+  resolveBaseUrl(baseUrl) {
+    return (baseUrl || process.env.PMATE_AGENT_API_BASE_URL || "https://agent-api.pmate.chat").replace(
+      /\/+$/,
+      ""
+    );
+  }
+  async requireNamespace(namespace, registryBaseUrl) {
+    const registry = new NamespaceRegistry({
+      chain: "pmate",
+      registryBaseUrl: this.resolveNamespaceBaseUrl(registryBaseUrl)
+    });
+    const exists = await registry.exists(namespace);
+    if (!exists) {
+      throw new Error(`Namespace "${namespace}" is not registered. Run: pmate ns create ${namespace}`);
+    }
+  }
+  resolveNamespaceBaseUrl(baseUrl) {
+    const envBaseUrl = process.env.PMATE_NAMESPACE_API_BASE_URL || process.env.PMATE_APPS_API_BASE_URL;
+    if (envBaseUrl) {
+      return envBaseUrl.replace(/\/+$/, "");
+    }
+    return baseUrl.includes("agent-api") || baseUrl.includes("agent.local") ? baseUrl.replace("agent-api", "apps-api").replace("agent.local", "apps.local") : baseUrl;
+  }
+  readToken() {
+    return readRequiredSession({
+      preferredApp: DEFAULT_APP_ID
+    }).token;
+  }
+  readJsonFile(filePath) {
+    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
+      throw new Error(`JSON file not found: ${absolutePath}`);
+    }
+    const raw = (0, import_node_fs12.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}`);
+    }
+  }
+  async request(baseUrl, token, method, pathname, body) {
+    const response = await fetch(`${baseUrl}${pathname}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    let payload = null;
+    try {
+      payload = await response.json();
+    } catch {
+      payload = null;
+    }
+    if (!response.ok || !payload?.success) {
+      throw new Error(payload?.message || `Request failed with status ${response.status}`);
+    }
+    return payload.data;
+  }
+  renderList(items, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(items, null, 2));
+      return;
+    }
+    if (items.length === 0) {
+      ui.warn("No agents found.");
+      return;
+    }
+    for (const item of items) {
+      ui.info(`${item.namespace}/${item.name}`, {
+        status: item.status,
+        version: item.version
+      });
+    }
+  }
+  renderJson(value, asJson) {
+    if (!asJson) {
+      return;
+    }
+    ui.plain(JSON.stringify(value, null, 2));
+  }
+  renderNamespaces(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.namespace, {
+        status: item.status,
+        updatedAt: item.updatedAt
+      });
+    }
+  }
+};
+
+// src/commands/NsCommandHandler.ts
+init_sessionStore();
+var NsCommandHandler = class {
+  async handle(args) {
+    switch (args.action) {
+      case "list": {
+        const registry = this.createRegistry(args);
+        const items = await registry.list();
+        this.render(items, args.json);
+        return;
+      }
+      case "get": {
+        const registry = this.createRegistry(args);
+        const item = await registry.get(args.namespace);
+        if (!item) {
+          throw new Error(`Namespace "${args.namespace}" is not registered.`);
+        }
+        this.render(item, true);
+        return;
+      }
+      case "create": {
+        const registry = this.createRegistry(args, this.resolveAuthHeaders());
+        const item = await registry.create(args.namespace);
+        ui.success(`Created namespace ${item.namespace}`);
+        this.render(item, args.json);
+        return;
+      }
+    }
+  }
+  resolveBaseUrl(baseUrl) {
+    return (baseUrl || process.env.PMATE_NAMESPACE_API_BASE_URL || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
+  }
+  resolveAuthHeaders() {
+    return {
+      Authorization: `Bearer ${readRequiredSession({ preferredApp: DEFAULT_APP_ID }).token}`
+    };
+  }
+  createRegistry(args, headers) {
+    return new NamespaceRegistry({
+      chain: args.chain,
+      registryBaseUrl: this.resolveBaseUrl(args.baseUrl),
+      headers
+    });
+  }
+  render(value, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(value, null, 2));
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        ui.warn("No namespaces found.");
+        return;
+      }
+      for (const item of value) {
+        ui.info(`${item.chain ?? "pmate"}/${item.namespace}`, {
+          status: item.status
+        });
+      }
+      return;
+    }
+    ui.plain(JSON.stringify(value, null, 2));
+  }
+};
+
+// src/commands/StoreCommandHandler.ts
+var import_node_fs13 = require("fs");
+var import_node_path18 = __toESM(require("path"));
+var StoreCommandHandler = class {
+  async handle(args) {
+    if (args.scope === "namespace") {
+      const items = await this.listNamespaces(args);
+      this.renderNamespaceList(items, args.json);
+      return;
+    }
+    if (this.requiresRegisteredNamespace(args)) {
+      await this.requireNamespace(args);
+    }
+    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);
@@ -19269,6 +19455,25 @@ var StoreCommandHandler = class {
   resolveIndexerBaseUrl(indexerBaseUrl) {
     return (indexerBaseUrl || process.env.PMATE_STORE_INDEXER_BASE_URL || process.env.INDEXER_BASE_URL || "https://indexer.pmate.chat").replace(/\/+$/, "");
   }
+  async requireNamespace(args) {
+    const registry = new NamespaceRegistry({
+      chain: args.chain,
+      registryBaseUrl: this.resolveRegistryBaseUrl()
+    });
+    const exists = await registry.exists(args.namespace);
+    if (!exists) {
+      throw new Error(`Namespace "${args.namespace}" is not registered. Run: pmate ns create ${args.namespace}`);
+    }
+  }
+  resolveRegistryBaseUrl() {
+    return (process.env.PMATE_NAMESPACE_API_BASE_URL || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
+  }
+  requiresRegisteredNamespace(args) {
+    if (args.scope === "table") {
+      return args.action === "create" || args.action === "update" || args.action === "delete";
+    }
+    return args.action === "set" || args.action === "delete";
+  }
   async listNamespaces(args) {
     const baseUrl = this.resolveIndexerBaseUrl(args.indexerBaseUrl);
     const url = new URL(`/chains/${encodeURIComponent(args.chain)}/namespaces`, `${baseUrl}/`);
@@ -19368,6 +19573,7 @@ var AppCommandHandler = class {
       }
       case "create": {
         const payload = this.readJsonFile(args.filePath);
+        await this.requireNamespace(payload, baseUrl);
         const record = await this.request(
           baseUrl,
           token,
@@ -19446,6 +19652,17 @@ var AppCommandHandler = class {
     }
     return payload.data;
   }
+  async requireNamespace(payload, baseUrl) {
+    const namespace = readNamespaceFromPayload(payload);
+    const registry = new NamespaceRegistry({
+      chain: "pmate",
+      registryBaseUrl: baseUrl
+    });
+    const exists = await registry.exists(namespace);
+    if (!exists) {
+      throw new Error(`Namespace "${namespace}" is not registered. Run: pmate ns create ${namespace}`);
+    }
+  }
   renderList(items, asJson) {
     if (asJson) {
       ui.plain(JSON.stringify(items, null, 2));
@@ -19469,6 +19686,16 @@ var AppCommandHandler = class {
     ui.plain(JSON.stringify(value, null, 2));
   }
 };
+function readNamespaceFromPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("App payload must be a JSON object.");
+  }
+  const namespace = payload.namespace;
+  if (typeof namespace !== "string" || !namespace.trim()) {
+    throw new Error("App payload.namespace is required.");
+  }
+  return namespace.trim().toLowerCase();
+}
 
 // src/commands/VercelCommandHandler.ts
 var import_node_child_process10 = require("child_process");
@@ -19586,7 +19813,7 @@ function parseAgentArgs(tokens) {
   }
   let baseUrl;
   let json = false;
-  const takeSharedOptions2 = () => {
+  const takeSharedOptions3 = () => {
     while (rest.length > 0) {
       const token = rest[0];
       if (token === "--base-url") {
@@ -19603,7 +19830,7 @@ function parseAgentArgs(tokens) {
     }
   };
   if (action === "namespaces") {
-    takeSharedOptions2();
+    takeSharedOptions3();
     if (rest.length > 0) {
       throw new Error(`Unknown agent namespaces option: ${rest[0]}`);
     }
@@ -19645,7 +19872,7 @@ function parseAgentArgs(tokens) {
         `Usage: agent ${action} [<namespace>] <name> [--base-url <url>] [--json]`
       );
     }
-    takeSharedOptions2();
+    takeSharedOptions3();
     if (rest.length > 0) {
       throw new Error(`Unknown agent ${action} option: ${rest[0]}`);
     }
@@ -19726,8 +19953,79 @@ function requireValue(tokens, optionName) {
   return value;
 }
 
-// src/storeCommandParser.ts
+// src/nsCommandParser.ts
 var DEFAULT_CHAIN = "pmate";
+function parseNsArgs(tokens) {
+  const rest = [...tokens];
+  const action = rest.shift();
+  if (!action) {
+    throw new Error("Missing ns action. Use: ns list|get|create");
+  }
+  let chain = DEFAULT_CHAIN;
+  let baseUrl;
+  let json = false;
+  if (action === "list") {
+    takeSharedOptions(rest, {
+      onChain: (value) => {
+        chain = value;
+      },
+      onBaseUrl: (value) => {
+        baseUrl = value;
+      },
+      onJson: () => {
+        json = true;
+      }
+    });
+    return { type: "ns" /* Ns */, action, chain, baseUrl, json };
+  }
+  if (action === "get" || action === "create") {
+    const namespace = rest.shift();
+    if (!namespace || namespace.startsWith("-")) {
+      throw new Error(`Usage: ns ${action} <namespace> [--chain <chain>] [--base-url <url>] [--json]`);
+    }
+    takeSharedOptions(rest, {
+      onChain: (value) => {
+        chain = value;
+      },
+      onBaseUrl: (value) => {
+        baseUrl = value;
+      },
+      onJson: () => {
+        json = true;
+      }
+    });
+    return { type: "ns" /* Ns */, action, namespace, chain, baseUrl, json };
+  }
+  throw new Error(`Unknown ns action: ${action}`);
+}
+function takeSharedOptions(rest, handlers) {
+  while (rest.length > 0) {
+    const token = rest.shift();
+    switch (token) {
+      case "--chain":
+        handlers.onChain(requireValue2(rest, token));
+        break;
+      case "--base-url":
+        handlers.onBaseUrl(requireValue2(rest, token));
+        break;
+      case "--json":
+        handlers.onJson();
+        break;
+      default:
+        throw new Error(`Unknown ns option: ${token}`);
+    }
+  }
+}
+function requireValue2(tokens, optionName) {
+  const value = tokens.shift();
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${optionName}`);
+  }
+  return value;
+}
+
+// src/storeCommandParser.ts
+var DEFAULT_CHAIN2 = "pmate";
 var DEFAULT_NAMESPACE2 = "pmate";
 function parseStoreArgs(tokens) {
   const rest = [...tokens];
@@ -19740,7 +20038,7 @@ function parseStoreArgs(tokens) {
     throw new Error(`Missing store ${scope} action.`);
   }
   const shared = {
-    chain: DEFAULT_CHAIN,
+    chain: DEFAULT_CHAIN2,
     namespace: DEFAULT_NAMESPACE2,
     baseUrl: void 0,
     indexerBaseUrl: void 0,
@@ -19750,7 +20048,7 @@ function parseStoreArgs(tokens) {
     if (action !== "list") {
       throw new Error(`Unknown store namespace action: ${action}`);
     }
-    takeSharedOptions(rest, shared);
+    takeSharedOptions2(rest, shared);
     if (rest.length > 0) {
       throw new Error(`Unknown store namespace option: ${rest[0]}`);
     }
@@ -19780,7 +20078,7 @@ function parseTableArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--page":
-          page = parsePage(requireValue2(rest, token));
+          page = parsePage(requireValue3(rest, token));
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19794,7 +20092,7 @@ function parseTableArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--id":
-          id = requireValue2(rest, token);
+          id = requireValue3(rest, token);
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19811,7 +20109,7 @@ function parseTableArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--file":
-          filePath = requireValue2(rest, token);
+          filePath = requireValue3(rest, token);
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19835,7 +20133,7 @@ function parseKvArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--page":
-          page = parsePage(requireValue2(rest, token));
+          page = parsePage(requireValue3(rest, token));
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19849,7 +20147,7 @@ function parseKvArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--key":
-          key = requireValue2(rest, token);
+          key = requireValue3(rest, token);
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19868,13 +20166,13 @@ function parseKvArgs(action, rest, shared) {
       const token = rest.shift();
       switch (token) {
         case "--key":
-          key = requireValue2(rest, token);
+          key = requireValue3(rest, token);
           break;
         case "--value":
-          value = requireValue2(rest, token);
+          value = requireValue3(rest, token);
           break;
         case "--file":
-          filePath = requireValue2(rest, token);
+          filePath = requireValue3(rest, token);
           break;
         default:
           pushSharedOption(token, rest, shared);
@@ -19890,7 +20188,7 @@ function parseKvArgs(action, rest, shared) {
   }
   throw new Error(`Unknown store kv action: ${action}`);
 }
-function takeSharedOptions(rest, shared) {
+function takeSharedOptions2(rest, shared) {
   while (rest.length > 0) {
     const token = rest.shift();
     pushSharedOption(token, rest, shared);
@@ -19899,17 +20197,17 @@ function takeSharedOptions(rest, shared) {
 function pushSharedOption(token, rest, shared) {
   switch (token) {
     case "--chain":
-      shared.chain = requireValue2(rest, token);
+      shared.chain = requireValue3(rest, token);
       break;
     case "--ns":
     case "--namespace":
-      shared.namespace = requireValue2(rest, token);
+      shared.namespace = requireValue3(rest, token);
       break;
     case "--base-url":
-      shared.baseUrl = requireValue2(rest, token);
+      shared.baseUrl = requireValue3(rest, token);
       break;
     case "--indexer-base-url":
-      shared.indexerBaseUrl = requireValue2(rest, token);
+      shared.indexerBaseUrl = requireValue3(rest, token);
       break;
     case "--json":
       shared.json = true;
@@ -19918,7 +20216,7 @@ function pushSharedOption(token, rest, shared) {
       throw new Error(`Unknown store option: ${token}`);
   }
 }
-function requireValue2(tokens, optionName) {
+function requireValue3(tokens, optionName) {
   const value = tokens.shift();
   if (!value || value.startsWith("-")) {
     throw new Error(`Missing value for ${optionName}`);
@@ -19942,12 +20240,12 @@ function parseAppArgs(tokens) {
   }
   let baseUrl;
   let json = false;
-  const takeSharedOptions2 = () => {
+  const takeSharedOptions3 = () => {
     while (rest.length > 0) {
       const token = rest[0];
       if (token === "--base-url") {
         rest.shift();
-        baseUrl = requireValue3(rest, token);
+        baseUrl = requireValue4(rest, token);
         continue;
       }
       if (token === "--json") {
@@ -19959,7 +20257,7 @@ function parseAppArgs(tokens) {
     }
   };
   if (action === "list") {
-    takeSharedOptions2();
+    takeSharedOptions3();
     if (rest.length > 0) {
       throw new Error(`Unknown app list option: ${rest[0]}`);
     }
@@ -19972,7 +20270,7 @@ function parseAppArgs(tokens) {
         `Usage: app ${action} <id> [--base-url <url>] [--json]`
       );
     }
-    takeSharedOptions2();
+    takeSharedOptions3();
     if (rest.length > 0) {
       throw new Error(`Unknown app ${action} option: ${rest[0]}`);
     }
@@ -19984,10 +20282,10 @@ function parseAppArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--file":
-          filePath = requireValue3(rest, token);
+          filePath = requireValue4(rest, token);
           break;
         case "--base-url":
-          baseUrl = requireValue3(rest, token);
+          baseUrl = requireValue4(rest, token);
           break;
         case "--json":
           json = true;
@@ -20013,10 +20311,10 @@ function parseAppArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--file":
-          filePath = requireValue3(rest, token);
+          filePath = requireValue4(rest, token);
           break;
         case "--base-url":
-          baseUrl = requireValue3(rest, token);
+          baseUrl = requireValue4(rest, token);
           break;
         case "--json":
           json = true;
@@ -20032,7 +20330,7 @@ function parseAppArgs(tokens) {
   }
   throw new Error(`Unknown app action: ${action}`);
 }
-function requireValue3(tokens, optionName) {
+function requireValue4(tokens, optionName) {
   const value = tokens.shift();
   if (!value || value.startsWith("-")) {
     throw new Error(`Missing value for ${optionName}`);
@@ -20063,7 +20361,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`,
@@ -20126,6 +20424,10 @@ 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("ns")}               Manage registered namespaces`,
+  `  ${import_chalk3.default.gray("                  list [--chain <chain>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk3.default.gray("                  get <namespace> [--chain <chain>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk3.default.gray("                  create <namespace> [--chain <chain>] [--base-url <url>] [--json]")}`,
   `  ${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]")}`,
@@ -20198,7 +20500,7 @@ function parseCommandArgs(args) {
       const token = rest.shift();
       switch (token) {
         case "--app":
-          app = requireValue4(rest, token);
+          app = requireValue5(rest, token);
           break;
         default:
           throw new Error(`Unknown login option: ${token}`);
@@ -20263,6 +20565,9 @@ function parseCommandArgs(args) {
   if (args.rest[0] === "agent") {
     return parseAgentArgs(args.rest.slice(1));
   }
+  if (args.rest[0] === "ns" || args.rest[0] === "namespace") {
+    return parseNsArgs(args.rest.slice(1));
+  }
   if (args.rest[0] === "store") {
     return parseStoreArgs(args.rest.slice(1));
   }
@@ -20286,7 +20591,7 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue4(rest, token);
+          scope = requireValue5(rest, token);
           break;
         default:
           throw new Error(`Unknown vercel option: ${token}`);
@@ -20306,10 +20611,10 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue4(rest, token);
+          scope = requireValue5(rest, token);
           break;
         case "--project":
-          project = requireValue4(rest, token);
+          project = requireValue5(rest, token);
           break;
         case "--last-week":
           lastWeek = true;
@@ -20340,16 +20645,16 @@ function parseAddDnsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--type":
-        options.dnsType = requireValue4(rest, token);
+        options.dnsType = requireValue5(rest, token);
         break;
       case "--value":
-        options.dnsValue = requireValue4(rest, token);
+        options.dnsValue = requireValue5(rest, token);
         break;
       case "--rr":
-        options.dnsRr = requireValue4(rest, token);
+        options.dnsRr = requireValue5(rest, token);
         break;
       case "--ttl": {
-        const ttlValue = requireValue4(rest, token);
+        const ttlValue = requireValue5(rest, token);
         const ttl = Number.parseInt(ttlValue, 10);
         if (!Number.isFinite(ttl) || ttl <= 0) {
           throw new Error(`Invalid --ttl value: ${ttlValue}`);
@@ -20358,7 +20663,7 @@ function parseAddDnsArgs(tokens) {
         break;
       }
       case "--domain":
-        options.dnsDomain = requireValue4(rest, token);
+        options.dnsDomain = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown add-dns option: ${token}`);
@@ -20379,7 +20684,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) {
@@ -20389,7 +20696,13 @@ function parseBucketArgs(tokens) {
         options.bucketCreate = true;
         break;
       case "--name":
-        options.bucketName = requireValue4(rest, token);
+        options.bucketName = requireValue5(rest, token);
+        break;
+      case "--subdomain":
+        options.bucketSubdomain = requireValue5(rest, token);
+        break;
+      case "--domain":
+        options.bucketDomain = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown bucket option: ${token}`);
@@ -20401,6 +20714,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) {
@@ -20425,7 +20741,7 @@ function parseDeployArgs(tokens) {
         options.deployAction = "logs";
         break;
       case "--cwd":
-        options.deployCwd = requireValue4(rest, token);
+        options.deployCwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown deploy option: ${token}`);
@@ -20450,13 +20766,13 @@ function parseLogArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.logCwd = requireValue4(rest, token);
+        options.logCwd = requireValue5(rest, token);
         break;
       case "--ns":
-        options.logNamespace = requireValue4(rest, token);
+        options.logNamespace = requireValue5(rest, token);
         break;
       case "--page": {
-        const value = requireValue4(rest, token);
+        const value = requireValue5(rest, token);
         const page = Number.parseInt(value, 10);
         if (!Number.isFinite(page) || page < 0) {
           throw new Error(`Invalid log page: ${value}`);
@@ -20468,7 +20784,7 @@ function parseLogArgs(tokens) {
         options.logHistory = true;
         break;
       case "--search":
-        options.logSearch = requireValue4(rest, token);
+        options.logSearch = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown log option: ${token}`);
@@ -20491,7 +20807,7 @@ function parseInitArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.initCwd = requireValue4(rest, token);
+        options.initCwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown init option: ${token}`);
@@ -20514,7 +20830,7 @@ function parseDevArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.devCwd = requireValue4(rest, token);
+        options.devCwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown dev option: ${token}`);
@@ -20544,13 +20860,13 @@ function parseOssArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--bucket":
-        bucket = requireValue4(rest, token);
+        bucket = requireValue5(rest, token);
         break;
       case "--file":
-        filePath = requireValue4(rest, token);
+        filePath = requireValue5(rest, token);
         break;
       case "--key":
-        objectKey = requireValue4(rest, token);
+        objectKey = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown oss option: ${token}`);
@@ -20583,7 +20899,7 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "set";
-        key = requireValue4(rest, token);
+        key = requireValue5(rest, token);
         break;
       case "--list":
         if (action) {
@@ -20596,17 +20912,17 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "delete";
-        key = requireValue4(rest, token);
+        key = requireValue5(rest, token);
         break;
       case "--value":
-        value = requireValue4(rest, token);
+        value = requireValue5(rest, token);
         break;
       case "--verbose":
       case "-v":
         verbose = true;
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown env option: ${token}`);
@@ -20664,7 +20980,7 @@ function parseCommitArgs(tokens) {
         push = true;
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown commit option: ${token}`);
@@ -20680,10 +20996,10 @@ function parseSummaryArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--pr":
-        prRef = requireValue4(rest, token);
+        prRef = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown summary option: ${token}`);
@@ -20752,10 +21068,10 @@ function parseLinearPrArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20784,35 +21100,35 @@ function parseLinearCreateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--repl":
         useRepl = true;
         break;
       case "--title":
-        title = requireValue4(rest, token);
+        title = requireValue5(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue4(rest, token));
+        description = decodeEscapedNewlines(requireValue5(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue4(rest, token);
+        teamId = requireValue5(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue4(rest, token);
+        teamKey = requireValue5(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue4(rest, token));
+        priority = parseLinearPriority(requireValue5(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue4(rest, token);
+        parentId = requireValue5(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue4(rest, token);
+        stateId = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20847,10 +21163,10 @@ function parseLinearWhoamiArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20875,10 +21191,10 @@ function parseLinearViewArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20913,32 +21229,32 @@ function parseLinearUpdateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--title":
-        title = requireValue4(rest, token);
+        title = requireValue5(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue4(rest, token));
+        description = decodeEscapedNewlines(requireValue5(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue4(rest, token);
+        teamId = requireValue5(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue4(rest, token);
+        teamKey = requireValue5(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue4(rest, token));
+        priority = parseLinearPriority(requireValue5(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue4(rest, token);
+        parentId = requireValue5(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue4(rest, token);
+        stateId = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -20976,10 +21292,10 @@ function parseLinearSubIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21006,15 +21322,15 @@ function parseLinearCommentArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--body":
       case "--desc":
       case "--description":
-        body = decodeEscapedNewlines(requireValue4(rest, token));
+        body = decodeEscapedNewlines(requireValue5(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21044,10 +21360,10 @@ function parseLinearCommentsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21071,16 +21387,16 @@ function parseLinearCycleArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue4(rest, token);
+        teamId = requireValue5(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue4(rest, token);
+        teamKey = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21103,10 +21419,10 @@ function parseLinearTeamsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21133,16 +21449,16 @@ function parseLinearUserIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue4(rest, token));
+        cycle = parseLinearCycle(requireValue5(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue4(rest, token));
+        status = parseLinearStatus(requireValue5(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21176,28 +21492,28 @@ function parseLinearIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue4(rest, token);
+        teamId = requireValue5(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue4(rest, token);
+        teamKey = requireValue5(rest, token);
         break;
       case "--user":
-        user = requireValue4(rest, token);
+        user = requireValue5(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue4(rest, token));
+        cycle = parseLinearCycle(requireValue5(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue4(rest, token));
+        status = parseLinearStatus(requireValue5(rest, token));
         break;
       case "--query":
-        query = requireValue4(rest, token).trim();
+        query = requireValue5(rest, token).trim();
         break;
       case "--limit": {
-        const value = Number.parseInt(requireValue4(rest, token), 10);
+        const value = Number.parseInt(requireValue5(rest, token), 10);
         if (!Number.isInteger(value) || value < 1 || value > 250) {
           throw new Error("Invalid --limit. Expected an integer between 1 and 250.");
         }
@@ -21205,7 +21521,7 @@ function parseLinearIssuesArgs(tokens) {
         break;
       }
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21246,10 +21562,10 @@ function parseLinearLegacyArgs(tokens) {
         useScreenshot = true;
         break;
       case "--account":
-        account = requireValue4(rest, token);
+        account = requireValue5(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue4(rest, token);
+        cwd = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21343,19 +21659,19 @@ function parseNotionArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--parent":
-          parentPageId = requireValue4(rest, token);
+          parentPageId = requireValue5(rest, token);
           break;
         case "--title":
-          title = requireValue4(rest, token);
+          title = requireValue5(rest, token);
           break;
         case "--private":
           isPrivate = true;
           break;
         case "--content":
-          content2 = requireValue4(rest, token);
+          content2 = requireValue5(rest, token);
           break;
         case "--file":
-          filePath2 = requireValue4(rest, token);
+          filePath2 = requireValue5(rest, token);
           break;
         default:
           throw new Error(`Unknown notion option: ${token}`);
@@ -21399,10 +21715,10 @@ function parseNotionArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--content":
-        content = requireValue4(rest, token);
+        content = requireValue5(rest, token);
         break;
       case "--file":
-        filePath = requireValue4(rest, token);
+        filePath = requireValue5(rest, token);
         break;
       case "--append":
         append = true;
@@ -21447,11 +21763,11 @@ function parseRandomArgs(tokens) {
         mode = "easy";
         break;
       case "--length":
-        length = parsePositiveInt(requireValue4(rest, token), token);
+        length = parsePositiveInt(requireValue5(rest, token), token);
         seenLength = true;
         break;
       case "--charset": {
-        const value = requireValue4(rest, token);
+        const value = requireValue5(rest, token);
         if (!["base64url", "hex", "alnum", "ascii"].includes(value)) {
           throw new Error(
             `Invalid --charset value: ${value}. Use base64url|hex|alnum|ascii.`
@@ -21462,18 +21778,18 @@ function parseRandomArgs(tokens) {
         break;
       }
       case "--count":
-        count = parsePositiveInt(requireValue4(rest, token), token);
+        count = parsePositiveInt(requireValue5(rest, token), token);
         break;
       case "--words":
-        words = parsePositiveInt(requireValue4(rest, token), token);
+        words = parsePositiveInt(requireValue5(rest, token), token);
         seenWords = true;
         break;
       case "--digits":
-        digits = parseNonNegativeInt(requireValue4(rest, token), token);
+        digits = parseNonNegativeInt(requireValue5(rest, token), token);
         seenDigits = true;
         break;
       case "--separator":
-        separator = requireValue4(rest, token);
+        separator = requireValue5(rest, token);
         seenSeparator = true;
         break;
       default:
@@ -21516,7 +21832,7 @@ function parseCollectArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--endpoint":
-        options.endpoint = requireValue4(rest, token);
+        options.endpoint = requireValue5(rest, token);
         break;
       case "--json":
         options.json = true;
@@ -21526,7 +21842,7 @@ function parseCollectArgs(tokens) {
         break;
       case "--thread":
         options.mode = "thread";
-        options.threadName = requireValue4(rest, token);
+        options.threadName = requireValue5(rest, token);
         break;
       default:
         throw new Error(`Unknown collect option: ${token}`);
@@ -21537,7 +21853,7 @@ function parseCollectArgs(tokens) {
   }
   return { type: "collect" /* Collect */, ...options };
 }
-function requireValue4(tokens, optionName) {
+function requireValue5(tokens, optionName) {
   const value = tokens.shift();
   if (!value) {
     throw new Error(`Missing value for ${optionName}`);
@@ -21678,6 +21994,11 @@ async function main() {
         await handler.handle(commandArgs);
         return;
       }
+      case "ns" /* Ns */: {
+        const handler = new NsCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
       case "store" /* Store */: {
         const handler = new StoreCommandHandler();
         await handler.handle(commandArgs);