@ainyc/canonry 1.1.0 → 1.3.0

package/README.md

@@ -6,6 +6,8 @@
 
 AEO (Answer Engine Optimization) is the practice of ensuring your content is accurately represented in AI-generated answers. As search shifts from links to synthesized responses, monitoring your visibility across answer engines is essential.
 
+![Canonry Dashboard](docs/images/dashboard.png)
+
 ## Quick Start
 
 ```bash
@@ -32,6 +34,7 @@ Open [http://localhost:4100](http://localhost:4100) to access the web dashboard.
 
 ```bash
 canonry init                        # Initialize config and database
+canonry bootstrap                   # Bootstrap hosted config/database from env vars
 canonry serve                       # Start server (API + web dashboard)
 canonry settings                    # View/edit configuration
 ```
@@ -237,6 +240,73 @@ pnpm run lint
 pnpm run dev:web          # Run SPA in dev mode
 ```
 
+## Docker Deployment
+
+Canonry currently deploys as a **single Node.js service with a SQLite file on persistent disk**.
+
+The repo includes a production `Dockerfile` and entry script. The default container entrypoint runs `canonry bootstrap` and then `canonry serve`.
+
+```bash
+docker build -t canonry .
+
+docker run --rm \
+  -p 4100:4100 \
+  -e PORT=4100 \
+  -e CANONRY_CONFIG_DIR=/data/canonry \
+  -e GEMINI_API_KEY=your-key \
+  -v canonry-data:/data \
+  canonry
+```
+
+Keep the container to a single replica and mount persistent storage at `/data` so SQLite and `config.yaml` survive restarts.
+
+No CORS configuration is required for this Docker setup. The dashboard and API are served by the same Canonry process on the same origin. CORS only becomes relevant if you split the frontend and API onto different domains.
+
+## Deploy on Railway or Render
+
+Use the **repo root** as the service root. `@ainyc/canonry` depends on shared workspace packages under `packages/*`, so deploying from a subdirectory will break the build.
+
+### Hosted environment variables
+
+Set at least one provider:
+
+- `GEMINI_API_KEY`
+- `OPENAI_API_KEY`
+- `ANTHROPIC_API_KEY`
+- `LOCAL_BASE_URL` (plus optional `LOCAL_API_KEY` and `LOCAL_MODEL`)
+
+Set these for hosted persistence/bootstrap:
+
+- `CANONRY_CONFIG_DIR=/data/canonry`
+- Optional `CANONRY_API_KEY=cnry_...` to pin the generated API key instead of letting bootstrap create one
+- Optional `CANONRY_DATABASE_PATH=/data/canonry/data.db`
+
+The hosted bootstrap command is idempotent. It creates `config.yaml`, creates or migrates the SQLite database, and inserts the API key row the server expects.
+
+### Railway
+
+Create one service from this repo using the checked-in `Dockerfile`, then attach a persistent volume mounted at `/data`.
+
+- Add the provider and Canonry env vars in the service's **Variables** tab. Railway can also bulk import them from `.env` files or the Raw Editor.
+- Leave the start command unset so Railway uses the image `ENTRYPOINT`.
+- Health check: `/health`
+- Recommended env: `CANONRY_CONFIG_DIR=/data/canonry`
+
+SQLite should live on the mounted volume, so keep the service to a single instance.
+
+### Render
+
+Create one **Web Service** from this repo with runtime **Docker**, then attach a persistent disk mounted at `/data`.
+
+- Add the provider and Canonry env vars in the service's **Environment** settings or an Environment Group.
+- Leave the start command unset so Render uses the image `ENTRYPOINT`.
+- Health check path: `/health`
+- Recommended env: `CANONRY_CONFIG_DIR=/data/canonry`
+
+Render makes Docker service env vars available at runtime and also exposes them to Docker builds as build args. This image does not use `ARG` for provider secrets, so those values are only consumed at runtime by the entry script and Canonry process.
+
+SQLite should live on the persistent disk, so keep the service to a single instance.
+
 ## Contributing
 
 Contributions are welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md) for setup instructions.

package/dist/{chunk-W6AJ2472.js → chunk-GUHHQZQM.js}

@@ -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() {
@@ -3697,13 +3701,14 @@ async function createServer(opts) {
 }
 
 export {
+  providerQuotaPolicySchema,
+  apiKeys,
+  createClient,
+  migrate,
   getConfigDir,
   getConfigPath,
   loadConfig,
   saveConfig,
   configExists,
-  apiKeys,
-  createClient,
-  migrate,
   createServer
 };

package/dist/cli.js

@@ -8,17 +8,169 @@ import {
   getConfigPath,
   loadConfig,
   migrate,
+  providerQuotaPolicySchema,
   saveConfig
-} from "./chunk-W6AJ2472.js";
+} from "./chunk-GUHHQZQM.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
 
-// src/commands/init.ts
+// src/commands/bootstrap.ts
 import crypto from "crypto";
+import path from "path";
+import { eq } from "drizzle-orm";
+
+// ../config/src/index.ts
+import { z } from "zod";
+var envSchema = z.object({
+  DATABASE_URL: z.string().default("postgresql://aeo:aeo@postgres:5432/aeo_platform"),
+  API_PORT: z.coerce.number().int().positive().default(3e3),
+  WORKER_PORT: z.coerce.number().int().positive().default(3001),
+  WEB_PORT: z.coerce.number().int().positive().default(4173),
+  BOOTSTRAP_SECRET: z.string().default("change-me"),
+  // Gemini
+  GEMINI_API_KEY: z.string().optional(),
+  GEMINI_MODEL: z.string().optional(),
+  GEMINI_MAX_CONCURRENCY: z.coerce.number().int().positive().default(2),
+  GEMINI_MAX_REQUESTS_PER_MINUTE: z.coerce.number().int().positive().default(10),
+  GEMINI_MAX_REQUESTS_PER_DAY: z.coerce.number().int().positive().default(1e3),
+  // OpenAI
+  OPENAI_API_KEY: z.string().optional(),
+  OPENAI_MODEL: z.string().optional(),
+  OPENAI_MAX_CONCURRENCY: z.coerce.number().int().positive().default(2),
+  OPENAI_MAX_REQUESTS_PER_MINUTE: z.coerce.number().int().positive().default(10),
+  OPENAI_MAX_REQUESTS_PER_DAY: z.coerce.number().int().positive().default(1e3),
+  // Anthropic / Claude
+  ANTHROPIC_API_KEY: z.string().optional(),
+  ANTHROPIC_MODEL: z.string().optional(),
+  ANTHROPIC_MAX_CONCURRENCY: z.coerce.number().int().positive().default(2),
+  ANTHROPIC_MAX_REQUESTS_PER_MINUTE: z.coerce.number().int().positive().default(10),
+  ANTHROPIC_MAX_REQUESTS_PER_DAY: z.coerce.number().int().positive().default(1e3)
+});
+var bootstrapEnvSchema = z.object({
+  CANONRY_API_KEY: z.string().optional(),
+  CANONRY_API_URL: z.string().optional(),
+  CANONRY_DATABASE_PATH: z.string().optional(),
+  GEMINI_API_KEY: z.string().optional(),
+  GEMINI_MODEL: z.string().optional(),
+  OPENAI_API_KEY: z.string().optional(),
+  OPENAI_MODEL: z.string().optional(),
+  ANTHROPIC_API_KEY: z.string().optional(),
+  ANTHROPIC_MODEL: z.string().optional(),
+  LOCAL_BASE_URL: z.string().optional(),
+  LOCAL_API_KEY: z.string().optional(),
+  LOCAL_MODEL: z.string().optional()
+});
+function getBootstrapEnv(source) {
+  const parsed = bootstrapEnvSchema.parse(source);
+  const providers = {};
+  if (parsed.GEMINI_API_KEY) {
+    providers.gemini = {
+      apiKey: parsed.GEMINI_API_KEY,
+      model: parsed.GEMINI_MODEL || "gemini-2.5-flash",
+      quota: providerQuotaPolicySchema.parse({
+        maxConcurrency: 2,
+        maxRequestsPerMinute: 10,
+        maxRequestsPerDay: 500
+      })
+    };
+  }
+  if (parsed.OPENAI_API_KEY) {
+    providers.openai = {
+      apiKey: parsed.OPENAI_API_KEY,
+      model: parsed.OPENAI_MODEL || "gpt-4o",
+      quota: providerQuotaPolicySchema.parse({
+        maxConcurrency: 2,
+        maxRequestsPerMinute: 10,
+        maxRequestsPerDay: 500
+      })
+    };
+  }
+  if (parsed.ANTHROPIC_API_KEY) {
+    providers.claude = {
+      apiKey: parsed.ANTHROPIC_API_KEY,
+      model: parsed.ANTHROPIC_MODEL || "claude-sonnet-4-6",
+      quota: providerQuotaPolicySchema.parse({
+        maxConcurrency: 2,
+        maxRequestsPerMinute: 10,
+        maxRequestsPerDay: 500
+      })
+    };
+  }
+  if (parsed.LOCAL_BASE_URL) {
+    providers.local = {
+      baseUrl: parsed.LOCAL_BASE_URL,
+      apiKey: parsed.LOCAL_API_KEY,
+      model: parsed.LOCAL_MODEL || "llama3",
+      quota: providerQuotaPolicySchema.parse({
+        maxConcurrency: 2,
+        maxRequestsPerMinute: 10,
+        maxRequestsPerDay: 500
+      })
+    };
+  }
+  return {
+    apiKey: parsed.CANONRY_API_KEY,
+    apiUrl: parsed.CANONRY_API_URL,
+    databasePath: parsed.CANONRY_DATABASE_PATH,
+    providers
+  };
+}
+
+// src/commands/bootstrap.ts
+async function bootstrapCommand(_opts) {
+  const env = getBootstrapEnv(process.env);
+  const providers = env.providers;
+  const hasProvider = providers?.gemini || providers?.openai || providers?.claude || providers?.local;
+  if (!hasProvider) {
+    throw new Error(
+      "Bootstrap requires at least one provider env var. Set GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, or LOCAL_BASE_URL."
+    );
+  }
+  const configDir = getConfigDir();
+  const databasePath = env.databasePath || path.join(configDir, "data.db");
+  const existing = configExists();
+  let rawApiKey;
+  let generatedApiKey;
+  if (env.apiKey) {
+    rawApiKey = env.apiKey;
+  } else if (existing) {
+    rawApiKey = loadConfig().apiKey;
+  } else {
+    generatedApiKey = `cnry_${crypto.randomBytes(16).toString("hex")}`;
+    rawApiKey = generatedApiKey;
+  }
+  const keyHash = crypto.createHash("sha256").update(rawApiKey).digest("hex");
+  const keyPrefix = rawApiKey.slice(0, 9);
+  const db = createClient(databasePath);
+  migrate(db);
+  db.delete(apiKeys).where(eq(apiKeys.name, "default")).run();
+  db.insert(apiKeys).values({
+    id: crypto.randomUUID(),
+    name: "default",
+    keyHash,
+    keyPrefix,
+    scopes: '["*"]',
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+  saveConfig({
+    apiUrl: env.apiUrl || `http://localhost:${process.env.CANONRY_PORT || "4100"}`,
+    database: databasePath,
+    apiKey: rawApiKey,
+    providers
+  });
+  console.log(`Bootstrap complete. Config saved to ${getConfigPath()}`);
+  console.log(`SQLite database path: ${databasePath}`);
+  if (generatedApiKey) {
+    console.log(`API key: ${generatedApiKey}`);
+  }
+}
+
+// src/commands/init.ts
+import crypto2 from "crypto";
 import fs from "fs";
 import readline from "readline";
-import path from "path";
+import path2 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -76,14 +228,14 @@ async function initCommand(opts) {
     console.error("\nAt least one provider is required.");
     process.exit(1);
   }
-  const rawApiKey = `cnry_${crypto.randomBytes(16).toString("hex")}`;
-  const keyHash = crypto.createHash("sha256").update(rawApiKey).digest("hex");
+  const rawApiKey = `cnry_${crypto2.randomBytes(16).toString("hex")}`;
+  const keyHash = crypto2.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
-  const databasePath = path.join(configDir, "data.db");
+  const databasePath = path2.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
-    id: crypto.randomUUID(),
+    id: crypto2.randomUUID(),
     name: "default",
     keyHash,
     keyPrefix,
@@ -132,8 +284,8 @@ var ApiClient = class {
     this.baseUrl = baseUrl.replace(/\/$/, "") + "/api/v1";
     this.apiKey = apiKey;
   }
-  async request(method, path2, body) {
-    const url = `${this.baseUrl}${path2}`;
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
       "Content-Type": "application/json"
@@ -675,6 +827,7 @@ canonry \u2014 AEO monitoring CLI
 
 Usage:
   canonry init [--force]               Initialize config and database
+  canonry bootstrap [--force]          Bootstrap config/database from env vars
   canonry serve                       Start the local server
   canonry project create <name>       Create a project
   canonry project list                List all projects
@@ -741,6 +894,11 @@ async function main() {
         await initCommand({ force: initForce });
         break;
       }
+      case "bootstrap": {
+        const bootstrapForce = args.includes("--force") || args.includes("-f");
+        await bootstrapCommand({ force: bootstrapForce });
+        break;
+      }
       case "serve": {
         const { values } = parseArgs({
           args: args.slice(1),

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createServer,
   loadConfig
-} from "./chunk-W6AJ2472.js";
+} from "./chunk-GUHHQZQM.js";
 export {
   createServer,
   loadConfig

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@ainyc/canonry",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "module",
+  "description": "The ultimate open-source AEO monitoring tool - track how answer engines cite your domain",
   "license": "AGPL-3.0-only",
+  "homepage": "https://ainyc.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AINYC/canonry.git",
+    "directory": "packages/canonry"
+  },
+  "bugs": {
+    "url": "https://github.com/AINYC/canonry/issues"
+  },
   "bin": {
     "canonry": "./bin/canonry.mjs"
   },
@@ -42,12 +52,13 @@
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",
     "@ainyc/canonry-api-routes": "0.0.0",
+    "@ainyc/canonry-config": "0.0.0",
     "@ainyc/canonry-contracts": "0.0.0",
-    "@ainyc/canonry-provider-claude": "0.0.0",
-    "@ainyc/canonry-provider-gemini": "0.0.0",
+    "@ainyc/canonry-db": "0.0.0",
     "@ainyc/canonry-provider-local": "0.0.0",
-    "@ainyc/canonry-provider-openai": "0.0.0",
-    "@ainyc/canonry-db": "0.0.0"
+    "@ainyc/canonry-provider-gemini": "0.0.0",
+    "@ainyc/canonry-provider-claude": "0.0.0",
+    "@ainyc/canonry-provider-openai": "0.0.0"
   },
   "scripts": {
     "build": "tsup && tsx build-web.ts",