npm - @ainyc/canonry - Versions diffs - 1.1.2 → 1.4.0 - Mend

@ainyc/canonry 1.1.2 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +83 -3
package/assets/assets/{index-CkNSldWM.css → index-DIAYCN3N.css} +1 -1
package/assets/assets/index-DYQXN-Fe.js +204 -0
package/assets/index.html +2 -2
package/dist/{chunk-W6AJ2472.js → chunk-WHOSB4LV.js} +298 -20
package/dist/cli.js +274 -29
package/dist/index.js +1 -1
package/package.json +5 -4
package/assets/assets/index-DHoyZdlF.js +0 -63

package/assets/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
       content="Canonry is the AINYC monitoring dashboard for answer visibility and technical readiness."
     />
     <title>Canonry</title>
-    <script type="module" crossorigin src="/assets/index-DHoyZdlF.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CkNSldWM.css">
+    <script type="module" crossorigin src="/assets/index-DYQXN-Fe.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DIAYCN3N.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/{chunk-W6AJ2472.js → chunk-WHOSB4LV.js} RENAMED Viewed

@@ -10,6 +10,10 @@ import path from "path";
 import os from "os";
 import { parse, stringify } from "yaml";
 function getConfigDir() {
+  const override = process.env.CANONRY_CONFIG_DIR?.trim();
+  if (override) {
+    return override;
+  }
   return path.join(os.homedir(), ".canonry");
 }
 function getConfigPath() {
@@ -39,12 +43,6 @@ function loadConfig() {
       }
     };
   }
-  const hasProvider = parsed.providers && (parsed.providers.gemini?.apiKey || parsed.providers.openai?.apiKey || parsed.providers.claude?.apiKey || parsed.providers.local?.baseUrl);
-  if (!hasProvider) {
-    throw new Error(
-      `No providers configured at ${configPath}. At least one provider is required.`
-    );
-  }
   return parsed;
 }
 function saveConfig(config) {
@@ -385,7 +383,12 @@ var providerQuotaPolicySchema = z.object({
   maxRequestsPerMinute: z.number().int().positive(),
   maxRequestsPerDay: z.number().int().positive()
 });
-var providerNameSchema = z.enum(["gemini", "openai", "claude", "local"]);
+var PROVIDER_NAMES = ["gemini", "openai", "claude", "local"];
+var providerNameSchema = z.enum(PROVIDER_NAMES);
+function parseProviderName(input) {
+  const lower = input.trim().toLowerCase();
+  return PROVIDER_NAMES.includes(lower) ? lower : void 0;
+}
 // ../contracts/src/notification.ts
 import { z as z2 } from "zod";
@@ -802,7 +805,7 @@ function formatProject(row) {
 // ../api-routes/src/keywords.ts
 import crypto4 from "crypto";
 import { eq as eq4 } from "drizzle-orm";
-async function keywordRoutes(app) {
+async function keywordRoutes(app, opts) {
   app.get("/projects/:name/keywords", async (request, reply) => {
     const project = resolveProjectSafe(app, request.params.name, reply);
     if (!project) return;
@@ -875,6 +878,45 @@ async function keywordRoutes(app) {
     const rows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
+  app.post("/projects/:name/keywords/generate", async (request, reply) => {
+    const project = resolveProjectSafe(app, request.params.name, reply);
+    if (!project) return;
+    const body = request.body;
+    if (!body?.provider || typeof body.provider !== "string") {
+      const err = validationError('Body must contain a "provider" string');
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    const provider = parseProviderName(body.provider);
+    if (!provider) {
+      const err = validationError(`Unknown provider "${body.provider}". Valid providers: gemini, openai, claude, local`);
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
+      const err = validationError('"count" must be an integer');
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    const count = Math.min(Math.max(body.count ?? 5, 1), 20);
+    if (!opts.onGenerateKeywords) {
+      return reply.status(501).send({ error: "Key phrase generation is not supported in this deployment" });
+    }
+    const existingRows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
+    const existingKeywords = existingRows.map((r) => r.keyword);
+    try {
+      const generated = await opts.onGenerateKeywords(provider, count, {
+        domain: project.canonicalDomain,
+        displayName: project.displayName,
+        country: project.country,
+        language: project.language,
+        existingKeywords
+      });
+      return reply.send({ keywords: generated, provider });
+    } catch (err) {
+      request.log.error({ err }, "Key phrase generation failed");
+      return reply.status(500).send({
+        error: err instanceof Error ? err.message : "Failed to generate key phrases"
+      });
+    }
+  });
 }
 function resolveProjectSafe(app, name, reply) {
   try {
@@ -989,12 +1031,13 @@ async function runRoutes(app, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const trigger = request.body?.trigger ?? "manual";
     const rawProviders = request.body?.providers;
-    const validProviders = ["gemini", "openai", "claude", "local"];
     if (rawProviders?.length) {
-      const invalid = rawProviders.filter((p) => !validProviders.includes(p));
+      const parsed = rawProviders.map((p) => parseProviderName(p));
+      const invalid = rawProviders.filter((_, i) => !parsed[i]);
       if (invalid.length) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validProviders.join(", ")}` } });
+        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Invalid provider(s): ${invalid.join(", ")}. Must be one of: gemini, openai, claude, local` } });
       }
+      rawProviders.splice(0, rawProviders.length, ...parsed.filter(Boolean));
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     const queueResult = queueRunIfProjectIdle(app.db, {
@@ -1744,12 +1787,12 @@ async function settingsRoutes(app, opts) {
     providers: opts.providerSummary ?? []
   }));
   app.put("/settings/providers/:name", async (request, reply) => {
-    const { name } = request.params;
+    const providerName = parseProviderName(request.params.name);
     const { apiKey, baseUrl, model } = request.body ?? {};
-    const validProviders = ["gemini", "openai", "claude", "local"];
-    if (!validProviders.includes(name)) {
-      return reply.status(400).send({ error: `Invalid provider: ${name}. Must be one of: ${validProviders.join(", ")}` });
+    if (!providerName) {
+      return reply.status(400).send({ error: `Invalid provider: ${request.params.name}. Must be one of: gemini, openai, claude, local` });
     }
+    const name = providerName;
     if (name === "local") {
       if (!baseUrl || typeof baseUrl !== "string") {
         return reply.status(400).send({ error: "baseUrl is required for local provider" });
@@ -2074,7 +2117,9 @@ async function apiRoutes(app, opts) {
     await api.register(projectRoutes, {
       onProjectDeleted: opts.onProjectDeleted
     });
-    await api.register(keywordRoutes);
+    await api.register(keywordRoutes, {
+      onGenerateKeywords: opts.onGenerateKeywords
+    });
     await api.register(competitorRoutes);
     await api.register(runRoutes, { onRunCreated: opts.onRunCreated });
     await api.register(applyRoutes, {
@@ -2254,6 +2299,13 @@ function extractDomainFromUri(uri) {
     return null;
   }
 }
+async function generateText(prompt, config) {
+  const model = resolveModel(config);
+  const genAI = new GoogleGenerativeAI(config.apiKey);
+  const generativeModel = genAI.getGenerativeModel({ model });
+  const result = await generativeModel.generateContent(prompt);
+  return result.response.text();
+}
 function responseToRecord(response) {
   try {
     const candidates = response.candidates?.map((c) => ({
@@ -2332,6 +2384,9 @@ var geminiAdapter = {
       groundingSources: normalized.groundingSources,
       searchQueries: normalized.searchQueries
     };
+  },
+  async generateText(prompt, config) {
+    return generateText(prompt, toGeminiConfig(config));
   }
 };
@@ -2494,6 +2549,15 @@ function extractDomainFromUri2(uri) {
     return null;
   }
 }
+async function generateText2(prompt, config) {
+  const model = config.model ?? DEFAULT_MODEL2;
+  const client = new OpenAI({ apiKey: config.apiKey });
+  const response = await client.chat.completions.create({
+    model,
+    messages: [{ role: "user", content: prompt }]
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
 function responseToRecord2(response) {
   try {
     return JSON.parse(JSON.stringify(response));
@@ -2561,6 +2625,9 @@ var openaiAdapter = {
       groundingSources: normalized.groundingSources,
       searchQueries: normalized.searchQueries
     };
+  },
+  async generateText(prompt, config) {
+    return generateText2(prompt, toOpenAIConfig(config));
   }
 };
@@ -2718,6 +2785,16 @@ function extractDomainFromUri3(uri) {
     return null;
   }
 }
+async function generateText3(prompt, config) {
+  const model = config.model ?? DEFAULT_MODEL3;
+  const client = new Anthropic({ apiKey: config.apiKey });
+  const response = await client.messages.create({
+    model,
+    max_tokens: 2048,
+    messages: [{ role: "user", content: prompt }]
+  });
+  return extractTextFromResponse(response);
+}
 function responseToRecord3(response) {
   try {
     return JSON.parse(JSON.stringify(response));
@@ -2785,6 +2862,9 @@ var claudeAdapter = {
       groundingSources: normalized.groundingSources,
       searchQueries: normalized.searchQueries
     };
+  },
+  async generateText(prompt, config) {
+    return generateText3(prompt, toClaudeConfig(config));
   }
 };
@@ -2881,6 +2961,18 @@ function extractAnswerText2(rawResponse) {
     return "";
   }
 }
+async function generateText4(prompt, config) {
+  const model = config.model ?? DEFAULT_MODEL4;
+  const client = new OpenAI2({
+    baseURL: config.baseUrl,
+    apiKey: config.apiKey || "not-needed"
+  });
+  const response = await client.chat.completions.create({
+    model,
+    messages: [{ role: "user", content: prompt }]
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
 function extractDomainMentions(text2) {
   const domains = /* @__PURE__ */ new Set();
   const urlPattern = /https?:\/\/([a-zA-Z0-9][-a-zA-Z0-9]*(?:\.[a-zA-Z0-9][-a-zA-Z0-9]*)+)/g;
@@ -2955,12 +3047,15 @@ var localAdapter = {
       groundingSources: normalized.groundingSources,
       searchQueries: normalized.searchQueries
     };
+  },
+  async generateText(prompt, config) {
+    return generateText4(prompt, toLocalConfig(config));
   }
 };
 // src/job-runner.ts
 import crypto11 from "crypto";
-import { eq as eq12 } from "drizzle-orm";
+import { eq as eq12, inArray as inArray2 } from "drizzle-orm";
 var JobRunner = class {
   db;
   registry;
@@ -2969,6 +3064,15 @@ var JobRunner = class {
     this.db = db;
     this.registry = registry;
   }
+  recoverStaleRuns() {
+    const stale = this.db.select({ id: runs.id, status: runs.status }).from(runs).where(inArray2(runs.status, ["running", "queued"])).all();
+    if (stale.length === 0) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const run of stale) {
+      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq12(runs.id, run.id)).run();
+      console.log(`[JobRunner] Recovered stale run ${run.id} (was ${run.status})`);
+    }
+  }
   async executeRun(runId, projectId, providerOverride) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     try {
@@ -3507,6 +3611,117 @@ var Notifier = class {
   }
 };
+// src/site-fetch.ts
+import https2 from "https";
+var FETCH_TIMEOUT_MS = 1e4;
+var MAX_TEXT_LENGTH = 4e3;
+var MAX_BODY_BYTES = 512e3;
+var USER_AGENT = "Canonry/1.0 (site-analysis)";
+function extractHostname(domain) {
+  let hostname = domain;
+  try {
+    if (hostname.includes("://")) {
+      hostname = new URL(hostname).hostname;
+    }
+  } catch {
+  }
+  return hostname.replace(/^www\./, "");
+}
+function fetchWithPinnedAddress(target) {
+  return new Promise((resolve) => {
+    const port = target.url.port ? Number(target.url.port) : 443;
+    const path3 = target.url.pathname + target.url.search;
+    const req = https2.request(
+      {
+        hostname: target.address,
+        family: target.family,
+        port,
+        path: path3,
+        method: "GET",
+        timeout: FETCH_TIMEOUT_MS,
+        servername: target.url.hostname,
+        // SNI for TLS
+        headers: {
+          Host: target.url.host,
+          "User-Agent": USER_AGENT,
+          Accept: "text/html"
+        }
+      },
+      (res) => {
+        if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+          if (res.statusCode >= 300 && res.statusCode < 400) {
+            const location = res.headers.location ?? "";
+            res.resume();
+            resolve(`REDIRECT:${location}`);
+            return;
+          }
+          res.resume();
+          resolve("");
+          return;
+        }
+        const contentType = res.headers["content-type"] ?? "";
+        if (!contentType.includes("text/html")) {
+          res.resume();
+          resolve("");
+          return;
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        res.on("data", (chunk) => {
+          totalBytes += chunk.length;
+          if (totalBytes <= MAX_BODY_BYTES) {
+            chunks.push(chunk);
+          }
+        });
+        res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        res.on("error", () => resolve(""));
+      }
+    );
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", () => resolve(""));
+    req.end();
+  });
+}
+async function fetchSiteText(domain) {
+  const hostname = extractHostname(domain);
+  const url = `https://${hostname}`;
+  const targetCheck = await resolveWebhookTarget(url);
+  if (!targetCheck.ok) return "";
+  try {
+    const result = await fetchWithPinnedAddress(targetCheck.target);
+    if (result.startsWith("REDIRECT:")) {
+      const location = result.slice("REDIRECT:".length);
+      if (!location) return "";
+      const redirectUrl = new URL(location, url).href;
+      const redirectCheck = await resolveWebhookTarget(redirectUrl);
+      if (!redirectCheck.ok) return "";
+      const redirectResult = await fetchWithPinnedAddress(redirectCheck.target);
+      if (redirectResult.startsWith("REDIRECT:")) return "";
+      return stripHtml(redirectResult);
+    }
+    return stripHtml(result);
+  } catch {
+    return "";
+  }
+}
+function stripHtml(html) {
+  if (!html) return "";
+  let text2 = html.replace(/<script[\s\S]*?<\/script>/gi, " ");
+  text2 = text2.replace(/<style[\s\S]*?<\/style>/gi, " ");
+  text2 = text2.replace(/<[^>]+>/g, " ");
+  text2 = text2.replace(/&amp;/g, "&");
+  text2 = text2.replace(/&lt;/g, "<");
+  text2 = text2.replace(/&gt;/g, ">");
+  text2 = text2.replace(/&quot;/g, '"');
+  text2 = text2.replace(/&#39;/g, "'");
+  text2 = text2.replace(/&nbsp;/g, " ");
+  text2 = text2.replace(/\s+/g, " ").trim();
+  if (text2.length > MAX_TEXT_LENGTH) {
+    text2 = text2.slice(0, MAX_TEXT_LENGTH);
+  }
+  return text2;
+}
 // src/server.ts
 var _require = createRequire(import.meta.url);
 var { version: PKG_VERSION } = _require("../package.json");
@@ -3578,6 +3793,7 @@ async function createServer(opts) {
   const port = opts.config.port ?? 4100;
   const serverUrl = `http://localhost:${port}`;
   const jobRunner = new JobRunner(opts.db, registry);
+  jobRunner.recoverStaleRuns();
   const notifier = new Notifier(opts.db, serverUrl);
   jobRunner.onRunCompleted = (runId, projectId) => notifier.onRunCompleted(runId, projectId);
   const scheduler = new Scheduler(opts.db, {
@@ -3647,6 +3863,22 @@ async function createServer(opts) {
     },
     onProjectDeleted: (projectId) => {
       scheduler.remove(projectId);
+    },
+    onGenerateKeywords: async (providerName, count, project) => {
+      const provider = registry.get(providerName);
+      if (!provider) throw new Error(`Provider "${providerName}" is not configured`);
+      const siteText = await fetchSiteText(project.domain);
+      const prompt = buildKeywordGenerationPrompt({
+        domain: project.domain,
+        displayName: project.displayName,
+        country: project.country,
+        language: project.language,
+        existingKeywords: project.existingKeywords,
+        siteText,
+        count
+      });
+      const raw = await provider.adapter.generateText(prompt, provider.config);
+      return parseKeywordResponse(raw, count);
     }
   });
   const dirname2 = path2.dirname(fileURLToPath(import.meta.url));
@@ -3695,15 +3927,61 @@ async function createServer(opts) {
   });
   return app;
 }
+function buildKeywordGenerationPrompt(ctx) {
+  const lines = [
+    "You are an SEO and AEO (Answer Engine Optimization) expert. Given a website's content, generate search queries that potential users would type into AI answer engines (ChatGPT, Gemini, Claude) to find services, products, or information like what this site offers.",
+    "",
+    `Website: ${ctx.domain}`
+  ];
+  if (ctx.displayName) lines.push(`Business: ${ctx.displayName}`);
+  lines.push(`Country: ${ctx.country}`);
+  lines.push(`Language: ${ctx.language}`);
+  if (ctx.siteText) {
+    lines.push("", "--- Site Content ---", ctx.siteText, "--- End Site Content ---");
+  }
+  if (ctx.existingKeywords.length > 0) {
+    lines.push("", `Already tracking (do NOT duplicate): ${ctx.existingKeywords.join(", ")}`);
+  }
+  lines.push(
+    "",
+    `Generate exactly ${ctx.count} key phrases that:`,
+    '- Are short and concise (2-5 words each, like "best dentist brooklyn" not "what is the best dentist office in the brooklyn area for families")',
+    "- Are natural phrases people would type into AI answer engines",
+    "- Cover different intents (informational, transactional, navigational)",
+    `- Are relevant to the ${ctx.country} market in ${ctx.language}`,
+    "- Reflect the actual services/products/content found on the site",
+    "",
+    "Return ONLY the key phrases, one per line, no numbering or bullets."
+  );
+  return lines.join("\n");
+}
+function parseKeywordResponse(raw, count) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const line of raw.split("\n")) {
+    let cleaned = line.replace(/^\s*(?:\d+[.)]\s*|[-*•]\s*)/, "").trim();
+    cleaned = cleaned.replace(/^["']|["']$/g, "").trim();
+    if (!cleaned) continue;
+    if (/^(here are|sure|certainly|of course|i've|these are|below are)/i.test(cleaned)) continue;
+    if (cleaned.split(/\s+/).length > 8) continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push(cleaned);
+    if (results.length >= count) break;
+  }
+  return results;
+}
 export {
+  providerQuotaPolicySchema,
+  apiKeys,
+  createClient,
+  migrate,
   getConfigDir,
   getConfigPath,
   loadConfig,
   saveConfig,
   configExists,
-  apiKeys,
-  createClient,
-  migrate,
   createServer
 };