@nkmc/cli 0.1.0 → 0.2.0

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
-  getToken
+  getToken,
+  saveToken
 } from "./chunk-MPXYSTOK.js";
 
 // src/commands/register.ts
@@ -29,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.");
@@ -49,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."
@@ -64,7 +83,8 @@ async function runRegister(options) {
   const token = await resolveToken({
     token: options.token,
     adminToken: options.adminToken,
-    domain
+    domain,
+    gatewayUrl
   });
   await registerService({
     gatewayUrl,

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runRegister
-} from "./chunk-OV4JPTYH.js";
+} from "./chunk-5ZYHHSZI.js";
 import {
   saveAgentToken,
   saveToken
@@ -115,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;
@@ -146,11 +265,15 @@ function extractRouteFromCall(call, projectDir) {
   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) {
@@ -321,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-PZERV3OY.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) {
@@ -477,6 +600,34 @@ async 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 }));
@@ -523,6 +674,41 @@ function registerFsCommands(program2) {
     try {
       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);
@@ -548,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,

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

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

package/package.json

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