@nkmc/cli 0.0.2 → 0.2.0

package/README.md

@@ -0,0 +1,156 @@
+# @nkmc/cli
+
+Command-line tool for the nkmc gateway. Scan your API, generate a `skill.md`, register it with the gateway, and interact with registered services as an agent.
+
+## Install
+
+```bash
+npm install -g @nkmc/cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate with the gateway (saves token to ~/.nkmc/credentials.json)
+nkmc auth
+
+# List services on the gateway
+nkmc ls /
+
+# Read a service's skill.md
+nkmc cat /api.weather.gov/skill.md
+```
+
+## Commands
+
+### `nkmc auth`
+
+Authenticate with the gateway. Fetches a JWT token (valid 24h) and saves it locally.
+
+```bash
+nkmc auth
+nkmc auth --gateway-url https://your-gateway.example.com
+```
+
+After authenticating, all `ls`/`cat`/`grep`/`write`/`rm` commands work without setting environment variables.
+
+### `nkmc init [dir]`
+
+Detect your project's framework and generate a `nkmc.config.ts` configuration file.
+
+```bash
+nkmc init
+```
+
+Supports Hono, Express, Fastify, and Next.js. Detects Prisma and Drizzle ORMs.
+
+### `nkmc generate [dir]`
+
+Scan your project and generate `.well-known/skill.md`.
+
+```bash
+nkmc generate
+nkmc generate --register --gateway-url https://api.nkmc.ai --domain myapi.com
+```
+
+Options:
+- `--register` — Register with the gateway after generating
+- `--gateway-url <url>` — Gateway URL for registration
+- `--token <token>` — Auth token for registration
+- `--domain <domain>` — Domain name for the service
+
+### `nkmc claim <domain>`
+
+Claim domain ownership via DNS TXT record verification.
+
+```bash
+# Step 1: Request a DNS challenge
+nkmc claim myapi.com --gateway-url https://api.nkmc.ai
+
+# Step 2: Add the TXT record to your DNS, then verify
+nkmc claim myapi.com --gateway-url https://api.nkmc.ai --verify
+```
+
+On success, a publish token is saved to `~/.nkmc/credentials.json` for that domain.
+
+### `nkmc register`
+
+Register your `skill.md` with the gateway.
+
+```bash
+nkmc register --gateway-url https://api.nkmc.ai --domain myapi.com
+```
+
+The token is resolved in this order:
+1. `--token` flag
+2. `NKMC_PUBLISH_TOKEN` env var
+3. Saved publish token from `nkmc claim`
+
+### `nkmc ls <path>`
+
+List files/services on the gateway.
+
+```bash
+nkmc ls /                          # List all services
+nkmc ls /api.weather.gov/          # List contents of a service
+```
+
+### `nkmc cat <path>`
+
+Read a file from the gateway.
+
+```bash
+nkmc cat /api.weather.gov/skill.md
+nkmc cat /api.weather.gov/alerts/active
+```
+
+### `nkmc grep <pattern> <path>`
+
+Search across services on the gateway.
+
+```bash
+nkmc grep "weather" /
+nkmc grep "forecast" /api.weather.gov/
+```
+
+### `nkmc write <path> <data>`
+
+Write data to a path on the gateway.
+
+### `nkmc rm <path>`
+
+Remove a file on the gateway.
+
+## Authentication
+
+The CLI resolves credentials in this order:
+
+1. `NKMC_TOKEN` / `NKMC_GATEWAY_URL` environment variables
+2. Saved agent token from `nkmc auth` (`~/.nkmc/credentials.json`)
+3. Default gateway URL: `https://api.nkmc.ai`
+
+## Configuration Directory
+
+Credentials are stored in `~/.nkmc/credentials.json` (permissions `0600`). Override the directory with the `NKMC_HOME` environment variable.
+
+## Workflow: Registering Your API
+
+```bash
+# 1. Initialize config
+nkmc init
+
+# 2. Generate skill.md
+nkmc generate
+
+# 3. Claim your domain
+nkmc claim myapi.com --gateway-url https://api.nkmc.ai
+# ... add DNS TXT record ...
+nkmc claim myapi.com --gateway-url https://api.nkmc.ai --verify
+
+# 4. Register with the gateway
+nkmc register --gateway-url https://api.nkmc.ai --domain myapi.com
+```
+
+## License
+
+MIT

package/dist/{chunk-53LSAGFF.js → chunk-5ZYHHSZI.js}

@@ -1,60 +1,16 @@
 #!/usr/bin/env node
+import {
+  getToken,
+  saveToken
+} from "./chunk-MPXYSTOK.js";
 
 // src/commands/register.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-
-// src/credentials.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFile } from "fs/promises";
 import { join } from "path";
-import { homedir } from "os";
-import { chmod } from "fs/promises";
-function nkmcDir() {
-  return process.env.NKMC_HOME || join(homedir(), ".nkmc");
-}
-function credentialsPath() {
-  return join(nkmcDir(), "credentials.json");
-}
-async function loadCredentials() {
-  try {
-    const raw = await readFile(credentialsPath(), "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return { tokens: {} };
-  }
-}
-async function saveToken(domain, publishToken) {
-  const creds = await loadCredentials();
-  const payloadB64 = publishToken.split(".")[1];
-  const payload = JSON.parse(
-    Buffer.from(payloadB64, "base64url").toString("utf-8")
-  );
-  creds.tokens[domain] = {
-    publishToken,
-    issuedAt: new Date(payload.iat * 1e3).toISOString(),
-    expiresAt: new Date(payload.exp * 1e3).toISOString()
-  };
-  const dir = nkmcDir();
-  await mkdir(dir, { recursive: true });
-  const filePath = credentialsPath();
-  await writeFile(filePath, JSON.stringify(creds, null, 2) + "\n");
-  await chmod(filePath, 384);
-}
-async function getToken(domain) {
-  const creds = await loadCredentials();
-  const entry = creds.tokens[domain];
-  if (!entry) return null;
-  if (new Date(entry.expiresAt).getTime() < Date.now()) {
-    return null;
-  }
-  return entry.publishToken;
-}
-
-// src/commands/register.ts
 async function registerService(options) {
   const { gatewayUrl, token, domain, skillMdPath } = options;
-  const mdPath = skillMdPath ?? join2(process.cwd(), ".well-known", "skill.md");
-  const skillMd = await readFile2(mdPath, "utf-8");
+  const mdPath = skillMdPath ?? join(process.cwd(), ".well-known", "skill.md");
+  const skillMd = await readFile(mdPath, "utf-8");
   if (!skillMd.trim()) {
     throw new Error(`skill.md is empty at ${mdPath}`);
   }
@@ -74,12 +30,35 @@ async function registerService(options) {
   const result = await res.json();
   console.log(`Registered ${result.name} as ${result.domain}`);
 }
+async function renewToken(gatewayUrl, domain) {
+  const baseUrl = gatewayUrl.replace(/\/$/, "");
+  try {
+    const res = await fetch(`${baseUrl}/domains/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ domain })
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data.publishToken) return null;
+    await saveToken(domain, data.publishToken);
+    console.log(`Token renewed for ${domain}`);
+    return data.publishToken;
+  } catch {
+    return null;
+  }
+}
 async function resolveToken(options) {
   if (options.token) return options.token;
   if (process.env.NKMC_PUBLISH_TOKEN) return process.env.NKMC_PUBLISH_TOKEN;
   if (options.domain) {
     const stored = await getToken(options.domain);
     if (stored) return stored;
+    const gw = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
+    if (gw) {
+      const renewed = await renewToken(gw, options.domain);
+      if (renewed) return renewed;
+    }
   }
   if (options.adminToken) {
     console.warn("Warning: --admin-token is deprecated. Use `nkmc claim` to obtain a publish token.");
@@ -94,13 +73,8 @@ async function resolveToken(options) {
 }
 async function runRegister(options) {
   const projectDir = options.dir ?? process.cwd();
-  const gatewayUrl = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
+  const gatewayUrl = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL ?? "https://api.nkmc.ai";
   const domain = options.domain ?? process.env.NKMC_DOMAIN;
-  if (!gatewayUrl) {
-    throw new Error(
-      "Gateway URL is required. Use --gateway-url or NKMC_GATEWAY_URL env var."
-    );
-  }
   if (!domain) {
     throw new Error(
       "Domain is required. Use --domain or NKMC_DOMAIN env var."
@@ -109,18 +83,18 @@ async function runRegister(options) {
   const token = await resolveToken({
     token: options.token,
     adminToken: options.adminToken,
-    domain
+    domain,
+    gatewayUrl
   });
   await registerService({
     gatewayUrl,
     token,
     domain,
-    skillMdPath: join2(projectDir, ".well-known", "skill.md")
+    skillMdPath: join(projectDir, ".well-known", "skill.md")
   });
 }
 
 export {
-  saveToken,
   registerService,
   resolveToken,
   runRegister

package/dist/chunk-MPXYSTOK.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+// src/credentials.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { chmod } from "fs/promises";
+function nkmcDir() {
+  return process.env.NKMC_HOME || join(homedir(), ".nkmc");
+}
+function credentialsPath() {
+  return join(nkmcDir(), "credentials.json");
+}
+async function loadCredentials() {
+  try {
+    const raw = await readFile(credentialsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { tokens: {} };
+  }
+}
+async function saveToken(domain, publishToken) {
+  const creds = await loadCredentials();
+  const payloadB64 = publishToken.split(".")[1];
+  const payload = JSON.parse(
+    Buffer.from(payloadB64, "base64url").toString("utf-8")
+  );
+  creds.tokens[domain] = {
+    publishToken,
+    issuedAt: new Date(payload.iat * 1e3).toISOString(),
+    expiresAt: new Date(payload.exp * 1e3).toISOString()
+  };
+  const dir = nkmcDir();
+  await mkdir(dir, { recursive: true });
+  const filePath = credentialsPath();
+  await writeFile(filePath, JSON.stringify(creds, null, 2) + "\n");
+  await chmod(filePath, 384);
+}
+async function saveAgentToken(gatewayUrl, token) {
+  const creds = await loadCredentials();
+  const payloadB64 = token.split(".")[1];
+  const payload = JSON.parse(
+    Buffer.from(payloadB64, "base64url").toString("utf-8")
+  );
+  creds.agentToken = {
+    token,
+    gatewayUrl,
+    issuedAt: new Date(payload.iat * 1e3).toISOString(),
+    expiresAt: new Date(payload.exp * 1e3).toISOString()
+  };
+  const dir = nkmcDir();
+  await mkdir(dir, { recursive: true });
+  const filePath = credentialsPath();
+  await writeFile(filePath, JSON.stringify(creds, null, 2) + "\n");
+  await chmod(filePath, 384);
+}
+async function getAgentToken() {
+  const creds = await loadCredentials();
+  const entry = creds.agentToken;
+  if (!entry) return null;
+  if (new Date(entry.expiresAt).getTime() < Date.now()) {
+    return null;
+  }
+  return entry;
+}
+async function getToken(domain) {
+  const creds = await loadCredentials();
+  const entry = creds.tokens[domain];
+  if (!entry) return null;
+  if (new Date(entry.expiresAt).getTime() < Date.now()) {
+    return null;
+  }
+  return entry.publishToken;
+}
+
+export {
+  loadCredentials,
+  saveToken,
+  saveAgentToken,
+  getAgentToken,
+  getToken
+};

package/dist/credentials-42DL3WPT.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  getAgentToken,
+  getToken,
+  loadCredentials,
+  saveAgentToken,
+  saveToken
+} from "./chunk-MPXYSTOK.js";
+export {
+  getAgentToken,
+  getToken,
+  loadCredentials,
+  saveAgentToken,
+  saveToken
+};

package/dist/index.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import {
-  runRegister,
+  runRegister
+} from "./chunk-5ZYHHSZI.js";
+import {
+  saveAgentToken,
   saveToken
-} from "./chunk-53LSAGFF.js";
+} from "./chunk-MPXYSTOK.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -112,18 +115,137 @@ async function scanRoutes(projectDir, framework) {
   }
   return scanCodeRoutes(projectDir);
 }
+function extractMountCalls(project) {
+  const mounts = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    const fileDir = dirname(filePath);
+    const importMap = /* @__PURE__ */ new Map();
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const specifier = imp.getModuleSpecifierValue();
+      const resolved = resolveModulePath(project, fileDir, specifier);
+      if (!resolved) continue;
+      for (const named of imp.getNamedImports()) {
+        const localName = named.getAliasNode()?.getText() || named.getName();
+        importMap.set(localName, resolved);
+      }
+      const defaultImport = imp.getDefaultImport();
+      if (defaultImport) {
+        importMap.set(defaultImport.getText(), resolved);
+      }
+    }
+    const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of calls) {
+      const expr = call.getExpression();
+      if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) continue;
+      const propAccess = expr.asKind(SyntaxKind.PropertyAccessExpression);
+      if (!propAccess || propAccess.getName() !== "route") continue;
+      const args = call.getArguments();
+      if (args.length < 2) continue;
+      const pathArg = args[0];
+      if (pathArg.getKind() !== SyntaxKind.StringLiteral) continue;
+      const mountPath = pathArg.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+      if (!mountPath) continue;
+      const childVar = args[1].getText();
+      const parentVar = propAccess.getExpression().getText();
+      mounts.push({
+        parentVar,
+        mountPath,
+        childVar,
+        childSourceFile: importMap.get(childVar) || null,
+        inFile: filePath
+      });
+    }
+  }
+  return mounts;
+}
+function resolveModulePath(project, fromDir, specifier) {
+  if (!specifier.startsWith(".")) return null;
+  const base = join3(fromDir, specifier);
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  for (const ext of extensions) {
+    if (project.getSourceFile(base + ext)) return base + ext;
+  }
+  for (const ext of extensions) {
+    const indexPath = join3(base, "index" + ext);
+    if (project.getSourceFile(indexPath)) return indexPath;
+  }
+  return null;
+}
+function computePrefixes(mounts) {
+  const filePrefixMap = /* @__PURE__ */ new Map();
+  const varPrefixMap = /* @__PURE__ */ new Map();
+  const localChildKeys = /* @__PURE__ */ new Set();
+  for (const m of mounts) {
+    if (!m.childSourceFile) {
+      localChildKeys.add(`${m.inFile}\0${m.childVar}`);
+    }
+  }
+  for (const m of mounts) {
+    const parentKey = `${m.inFile}\0${m.parentVar}`;
+    if (!localChildKeys.has(parentKey)) {
+      varPrefixMap.set(parentKey, "");
+    }
+  }
+  let changed = true;
+  let iterations = 0;
+  while (changed && iterations < 10) {
+    changed = false;
+    iterations++;
+    for (const m of mounts) {
+      const parentKey = `${m.inFile}\0${m.parentVar}`;
+      let parentPrefix = varPrefixMap.get(parentKey);
+      if (parentPrefix === void 0 && filePrefixMap.has(m.inFile)) {
+        parentPrefix = filePrefixMap.get(m.inFile);
+        varPrefixMap.set(parentKey, parentPrefix);
+        changed = true;
+      }
+      if (parentPrefix === void 0) continue;
+      const fullPrefix = joinPaths(parentPrefix, m.mountPath);
+      if (m.childSourceFile) {
+        if (!filePrefixMap.has(m.childSourceFile)) {
+          filePrefixMap.set(m.childSourceFile, fullPrefix);
+          changed = true;
+        }
+      } else {
+        const childKey = `${m.inFile}\0${m.childVar}`;
+        if (!varPrefixMap.has(childKey)) {
+          varPrefixMap.set(childKey, fullPrefix);
+          changed = true;
+        }
+      }
+    }
+  }
+  return { filePrefixMap, varPrefixMap };
+}
+function joinPaths(prefix, path) {
+  if (!prefix) return path;
+  if (path === "/") return prefix;
+  const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const cleanPath = path.startsWith("/") ? path : "/" + path;
+  return cleanPrefix + cleanPath;
+}
 async function scanCodeRoutes(projectDir) {
   const project = new Project({ skipAddingFilesFromTsConfig: true });
   const srcFiles = await findTsFiles(projectDir);
   for (const filePath of srcFiles) {
     project.addSourceFileAtPath(filePath);
   }
+  const mounts = extractMountCalls(project);
+  const { filePrefixMap, varPrefixMap } = computePrefixes(mounts);
   const routes = [];
   for (const sourceFile of project.getSourceFiles()) {
+    const absPath = sourceFile.getFilePath();
+    const filePrefix = filePrefixMap.get(absPath);
     const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
     for (const call of calls) {
-      const route = extractRouteFromCall(call, projectDir);
-      if (route) routes.push(route);
+      const result = extractRouteFromCall(call, projectDir);
+      if (!result) continue;
+      const { route, callerVar } = result;
+      const varKey = `${absPath}\0${callerVar}`;
+      const prefix = varPrefixMap.get(varKey) ?? filePrefix ?? "";
+      route.path = joinPaths(prefix, route.path);
+      routes.push(route);
     }
   }
   return routes;
@@ -140,14 +262,18 @@ function extractRouteFromCall(call, projectDir) {
   const firstArg = args[0];
   if (firstArg.getKind() !== SyntaxKind.StringLiteral) return null;
   const path = firstArg.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-  if (!path) return null;
+  if (!path || !path.startsWith("/")) return null;
   const description = extractLeadingComment(call);
   const filePath = relative(projectDir, call.getSourceFile().getFilePath());
+  const callerVar = propAccess.getExpression().getText();
   return {
-    method: methodName.toUpperCase(),
-    path,
-    filePath,
-    description
+    route: {
+      method: methodName.toUpperCase(),
+      path,
+      filePath,
+      description
+    },
+    callerVar
   };
 }
 function extractLeadingComment(call) {
@@ -192,7 +318,7 @@ async function findTsFiles(dir) {
 }
 async function findFiles(dir, pattern) {
   const results = [];
-  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", "build", ".git"]);
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", "build", ".git", ".wrangler", ".output", ".nuxt", ".svelte-kit", ".vercel"]);
   async function walk(current) {
     const entries = await readdir(current, { withFileTypes: true });
     for (const entry of entries) {
@@ -318,7 +444,7 @@ async function runGenerate(projectDir, options) {
   await writeFile2(outputPath, md);
   console.log(`Generated ${outputPath}`);
   if (options?.register) {
-    const { registerService, resolveToken } = await import("./register-GWQ2Z2YL.js");
+    const { registerService, resolveToken } = await import("./register-7SUETZ7U.js");
     const gatewayUrl = options.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
     const domain = options.domain ?? process.env.NKMC_DOMAIN;
     if (!gatewayUrl || !domain) {
@@ -409,6 +535,31 @@ Domain ${domain} verified successfully!`);
   console.log(`  nkmc register --domain ${domain}`);
 }
 
+// src/commands/auth.ts
+async function runAuth(opts) {
+  const gatewayUrl = opts.gatewayUrl ?? process.env.NKMC_GATEWAY_URL ?? "https://api.nkmc.ai";
+  const sub = `agent-${Date.now()}`;
+  const res = await fetch(`${gatewayUrl}/auth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      sub,
+      svc: "gateway",
+      roles: ["agent"],
+      expiresIn: "24h"
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Auth failed (${res.status}): ${body}`);
+  }
+  const { token } = await res.json();
+  await saveAgentToken(gatewayUrl, token);
+  console.log("Authenticated with gateway");
+  console.log(`  Token saved to ~/.nkmc/credentials.json`);
+  console.log(`  Gateway: ${gatewayUrl}`);
+}
+
 // src/gateway/client.ts
 var GatewayClient = class {
   constructor(gatewayUrl, token) {
@@ -432,11 +583,16 @@ var GatewayClient = class {
     return res.json();
   }
 };
-function createClient() {
-  const gatewayUrl = process.env.NKMC_GATEWAY_URL;
-  const token = process.env.NKMC_TOKEN;
-  if (!gatewayUrl) throw new Error("NKMC_GATEWAY_URL is required");
-  if (!token) throw new Error("NKMC_TOKEN is required");
+async function createClient() {
+  const { getAgentToken } = await import("./credentials-42DL3WPT.js");
+  const stored = await getAgentToken();
+  const gatewayUrl = process.env.NKMC_GATEWAY_URL ?? stored?.gatewayUrl ?? "https://api.nkmc.ai";
+  const token = process.env.NKMC_TOKEN ?? stored?.token ?? null;
+  if (!token) {
+    throw new Error(
+      "No token found. Run 'nkmc auth' first, or set NKMC_TOKEN."
+    );
+  }
   return new GatewayClient(gatewayUrl, token);
 }
 
@@ -444,6 +600,34 @@ function createClient() {
 function output(result) {
   console.log(JSON.stringify(result));
 }
+function isSearchResults(data) {
+  if (!Array.isArray(data) || data.length === 0) return false;
+  const first = data[0];
+  return typeof first === "object" && first !== null && "domain" in first && "name" in first;
+}
+function isEndpointResults(data) {
+  if (!Array.isArray(data) || data.length === 0) return false;
+  const first = data[0];
+  return typeof first === "object" && first !== null && "method" in first && "path" in first;
+}
+function formatGrepResults(data) {
+  if (isSearchResults(data)) {
+    return data.map((s) => {
+      const header = `${s.domain} \u2014 ${s.name}`;
+      if (!s.matchedEndpoints || s.matchedEndpoints.length === 0) {
+        return header;
+      }
+      const endpoints = s.matchedEndpoints.map((e) => `  ${e.method.padEnd(6)} ${e.path}  \u2014 ${e.description}`).join("\n");
+      return `${header} \xB7 ${s.matchedEndpoints.length} matched
+${endpoints}`;
+    }).join("\n\n");
+  }
+  if (isEndpointResults(data)) {
+    if (data.length === 0) return "No matching endpoints.";
+    return data.map((e) => `${e.method.padEnd(6)} ${e.path}  \u2014 ${e.description}`).join("\n");
+  }
+  return JSON.stringify(data);
+}
 function handleError(err) {
   const message = err instanceof Error ? err.message : String(err);
   console.error(JSON.stringify({ error: message }));
@@ -452,7 +636,7 @@ function handleError(err) {
 function registerFsCommands(program2) {
   program2.command("ls").description("List files in a directory").argument("<path>", "Directory path").action(async (path) => {
     try {
-      const client = createClient();
+      const client = await createClient();
       const result = await client.execute(`ls ${path}`);
       output(result);
     } catch (err) {
@@ -461,7 +645,7 @@ function registerFsCommands(program2) {
   });
   program2.command("cat").description("Read file contents").argument("<path>", "File path").action(async (path) => {
     try {
-      const client = createClient();
+      const client = await createClient();
       const result = await client.execute(`cat ${path}`);
       output(result);
     } catch (err) {
@@ -470,7 +654,7 @@ function registerFsCommands(program2) {
   });
   program2.command("write").description("Write data to a file").argument("<path>", "File path").argument("<data>", "Data to write").action(async (path, data) => {
     try {
-      const client = createClient();
+      const client = await createClient();
       const result = await client.execute(`write ${path} ${data}`);
       output(result);
     } catch (err) {
@@ -479,7 +663,7 @@ function registerFsCommands(program2) {
   });
   program2.command("rm").description("Remove a file").argument("<path>", "File path").action(async (path) => {
     try {
-      const client = createClient();
+      const client = await createClient();
       const result = await client.execute(`rm ${path}`);
       output(result);
     } catch (err) {
@@ -488,8 +672,43 @@ function registerFsCommands(program2) {
   });
   program2.command("grep").description("Search file contents").argument("<pattern>", "Search pattern").argument("<path>", "File or directory path").action(async (pattern, path) => {
     try {
-      const client = createClient();
+      const client = await createClient();
       const result = await client.execute(`grep ${pattern} ${path}`);
+      console.log(formatGrepResults(result));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("pipe").description("Pipe commands: cat <path> | write <path>").argument("<expression...>", "Pipe expression").action(async (expression) => {
+    try {
+      const full = expression.join(" ");
+      const parts = full.split("|").map((s) => s.trim());
+      if (parts.length !== 2) {
+        throw new Error("Pipe expression must have exactly two stages separated by '|'");
+      }
+      const [source, target] = parts;
+      if (!source.startsWith("cat ")) {
+        throw new Error("Pipe step 1 must be a 'cat' command");
+      }
+      if (!target.startsWith("write ")) {
+        throw new Error("Pipe step 2 must be a 'write' command");
+      }
+      const client = await createClient();
+      let data;
+      try {
+        data = await client.execute(source);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Pipe step 1 failed: ${msg}`);
+      }
+      const writePath = target.slice("write ".length).trim();
+      let result;
+      try {
+        result = await client.execute(`write ${writePath} ${JSON.stringify(data)}`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Pipe step 2 failed: ${msg}`);
+      }
       output(result);
     } catch (err) {
       handleError(err);
@@ -515,12 +734,7 @@ program.command("generate").description("Scan project and generate skill.md").ar
   });
 });
 program.command("claim <domain>").description("Claim domain ownership via DNS verification").option("--verify", "Verify DNS record and obtain publish token").option("--gateway-url <url>", "Gateway URL").action(async (domain, opts) => {
-  const gatewayUrl = opts.gatewayUrl ?? process.env.NKMC_GATEWAY_URL;
-  if (!gatewayUrl) {
-    throw new Error(
-      "Gateway URL is required. Use --gateway-url or NKMC_GATEWAY_URL env var."
-    );
-  }
+  const gatewayUrl = opts.gatewayUrl ?? process.env.NKMC_GATEWAY_URL ?? "https://api.nkmc.ai";
   await runClaim({
     gatewayUrl,
     domain,
@@ -536,5 +750,8 @@ program.command("register").description("Register skill.md with the gateway").op
     dir: opts.dir === "." ? process.cwd() : opts.dir
   });
 });
+program.command("auth").description("Authenticate with the nkmc gateway").option("--gateway-url <url>", "Gateway URL (default: https://api.nkmc.ai)").action(async (opts) => {
+  await runAuth({ gatewayUrl: opts.gatewayUrl });
+});
 registerFsCommands(program);
 program.parse();

package/dist/{register-GWQ2Z2YL.js → register-7SUETZ7U.js}

@@ -3,7 +3,8 @@ import {
   registerService,
   resolveToken,
   runRegister
-} from "./chunk-53LSAGFF.js";
+} from "./chunk-5ZYHHSZI.js";
+import "./chunk-MPXYSTOK.js";
 export {
   registerService,
   resolveToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkmc/cli",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "CLI for scanning and registering APIs with the nkmc gateway",
   "license": "MIT",
   "type": "module",