@ainyc/canonry 1.46.0 → 1.48.0

package/dist/cli.js

@@ -1,34 +1,53 @@
 #!/usr/bin/env node --import tsx
 import {
+  AGENT_WEBHOOK_EVENTS,
+  AgentManager,
+  CliError,
+  EXIT_SYSTEM_ERROR,
+  EXIT_USER_ERROR,
   ProviderNames,
   RunKinds,
+  attachAgentWebhookDirect,
+  buildAgentWebhookUrl,
   computeCompetitorOverlap,
   configExists,
+  configureOpenClawGateway,
   createServer,
+  detectOpenClaw,
   determineAnswerMentioned,
   determineCitationState,
   effectiveDomains,
   extractRecommendedCompetitors,
   formatAuditFactorScore,
+  getAeroStateDir,
   getConfigDir,
   getConfigPath,
   getOrCreateAnonymousId,
+  initializeOpenClawProfile,
+  installOpenClaw,
   isFirstRun,
   isTelemetryEnabled,
   loadConfig,
   notificationEventSchema,
+  printCliError,
+  providerEnvVar,
   providerQuotaPolicySchema,
   reparseStoredResult,
   reparseStoredResult2,
   reparseStoredResult3,
   reparseStoredResult4,
+  resolveAgentCredentials,
   resolveProviderInput,
   saveConfig,
   saveConfigPatch,
+  seedWorkspace,
   setGoogleAuthConfig,
+  setOpenClawModel,
   showFirstRunNotice,
-  trackEvent
-} from "./chunk-22RIKNII.js";
+  trackEvent,
+  usageError,
+  writeAgentEnv
+} from "./chunk-25QLMK4F.js";
 import {
   apiKeys,
   competitors,
@@ -43,84 +62,14 @@ import {
 // src/cli.ts
 import { pathToFileURL } from "url";
 
-// src/cli-error.ts
-var EXIT_USER_ERROR = 1;
-var EXIT_SYSTEM_ERROR = 2;
-var CliError = class extends Error {
-  code;
-  displayMessage;
-  details;
-  exitCode;
-  constructor(options) {
-    super(options.message);
-    this.name = "CliError";
-    this.code = options.code;
-    this.displayMessage = options.displayMessage;
-    this.details = options.details;
-    this.exitCode = options.exitCode ?? EXIT_USER_ERROR;
-  }
-};
-function usageError(displayMessage, options) {
-  const firstLine = displayMessage.split("\n", 1)[0] ?? "Error: invalid command usage";
-  return new CliError({
-    code: "CLI_USAGE_ERROR",
-    message: options?.message ?? firstLine.replace(/^Error:\s*/, ""),
-    displayMessage,
-    details: options?.details
-  });
-}
-function printCliError(err, format) {
-  if (format === "json") {
-    if (err instanceof CliError) {
-      console.error(
-        JSON.stringify(
-          {
-            error: {
-              code: err.code,
-              message: err.message,
-              ...err.details ? { details: err.details } : {}
-            }
-          },
-          null,
-          2
-        )
-      );
-      return;
-    }
-    const message = err instanceof Error ? err.message : "An unexpected error occurred";
-    console.error(
-      JSON.stringify(
-        {
-          error: {
-            code: "CLI_ERROR",
-            message
-          }
-        },
-        null,
-        2
-      )
-    );
-    return;
-  }
-  if (err instanceof CliError && err.displayMessage) {
-    console.error(err.displayMessage);
-    return;
-  }
-  if (err instanceof Error) {
-    console.error(`Error: ${err.message}`);
-    return;
-  }
-  console.error("An unexpected error occurred");
-}
-
 // src/cli-dispatch.ts
 import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path6) {
-  if (args.length < path6.length) return false;
-  return path6.every((segment, index) => args[index] === segment);
+function matchesPath(args, path7) {
+  if (args.length < path7.length) return false;
+  return path7.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -613,9 +562,9 @@ var ApiClient = class {
     }
     return this.probePromise;
   }
-  async request(method, path6, body) {
+  async request(method, path7, body) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path6}`;
+    const url = `${this.baseUrl}${path7}`;
     const serializedBody = body != null ? JSON.stringify(body) : void 0;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
@@ -3523,7 +3472,9 @@ var EVENT_DESCRIPTIONS = {
   "citation.lost": "A keyword lost its citation status",
   "citation.gained": "A keyword gained citation status",
   "run.completed": "A visibility run completed successfully",
-  "run.failed": "A visibility run failed"
+  "run.failed": "A visibility run failed",
+  "insight.critical": "A critical-severity insight was generated",
+  "insight.high": "A high-severity insight was generated"
 };
 function listEvents(format) {
   const events = notificationEventSchema.options;
@@ -6142,6 +6093,15 @@ var DEFAULT_QUOTA = {
   maxRequestsPerMinute: 10,
   maxRequestsPerDay: 500
 };
+var DEFAULT_AGENT_MODELS = {
+  anthropic: "anthropic/claude-sonnet-4-6",
+  openai: "openai/gpt-4o",
+  openrouter: "openrouter/anthropic/claude-sonnet-4-6",
+  groq: "groq/llama-4-scout-17b",
+  google: "google/gemini-2.5-flash",
+  mistral: "mistral/mistral-large-latest",
+  xai: "xai/grok-2"
+};
 async function initCommand(opts) {
   const format = opts?.format ?? "text";
   if (format !== "json") {
@@ -6154,11 +6114,11 @@ async function initCommand(opts) {
         reason: "config_exists",
         configPath: getConfigPath()
       }, null, 2));
-      return;
+      return void 0;
     }
     console.log(`Config already exists at ${getConfigPath()}`);
     console.log('To reinitialize, run "canonry init --force".');
-    return;
+    return void 0;
   }
   const configDir = getConfigDir();
   if (!fs6.existsSync(configDir)) {
@@ -6313,6 +6273,29 @@ Config saved to ${getConfigPath()}`);
     console.log(`API key: ${rawApiKey}`);
     console.log(`Providers: ${providerNames.join(", ")}`);
   }
+  let agentLLM;
+  const agentProvider = opts?.agentProvider;
+  const agentKey = opts?.agentKey;
+  const agentModel = opts?.agentModel;
+  if (agentProvider || agentKey || agentModel) {
+    const provider = agentProvider ?? "anthropic";
+    agentLLM = {
+      provider,
+      key: agentKey,
+      model: agentModel ?? DEFAULT_AGENT_MODELS[provider]
+    };
+  } else if (!nonInteractive) {
+    console.log("\nConfigure agent LLM (the model that powers the agent):");
+    console.log("Supported providers: anthropic, openai, openrouter, groq, mistral, xai, google, cerebras\n");
+    const provider = await prompt("Provider [anthropic]: ") || "anthropic";
+    const key = await prompt("API key (press Enter to skip): ");
+    if (key) {
+      const defaultModel = DEFAULT_AGENT_MODELS[provider];
+      const modelText = defaultModel ? `Model [${defaultModel}]: ` : "Model: ";
+      const model = await prompt(modelText) || defaultModel;
+      agentLLM = { provider, key, model };
+    }
+  }
   if (format !== "json") {
     showFirstRunNotice();
     console.log('Run "canonry serve" to start the server.');
@@ -6321,6 +6304,7 @@ Config saved to ${getConfigPath()}`);
     providerCount: providerNames.length,
     providers: providerNames
   });
+  return agentLLM;
 }
 
 // src/commands/serve.ts
@@ -6884,8 +6868,8 @@ async function wordpressSetMeta(project, body) {
 }
 async function wordpressBulkSetMeta(project, opts) {
   const fs8 = await import("fs/promises");
-  const path6 = await import("path");
-  const filePath = path6.resolve(opts.from);
+  const path7 = await import("path");
+  const filePath = path7.resolve(opts.from);
   let raw;
   try {
     raw = await fs8.readFile(filePath, "utf8");
@@ -6986,9 +6970,9 @@ async function wordpressSetSchema(project, body) {
 }
 async function wordpressSchemaDeploy(project, opts) {
   const fs8 = await import("fs/promises");
-  const path6 = await import("path");
+  const path7 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path6.resolve(opts.profile);
+  const filePath = path7.resolve(opts.profile);
   let raw;
   try {
     raw = await fs8.readFile(filePath, "utf8");
@@ -7097,9 +7081,9 @@ async function wordpressOnboard(project, opts) {
   let profileData;
   if (opts.profile) {
     const fs8 = await import("fs/promises");
-    const path6 = await import("path");
+    const path7 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path6.resolve(opts.profile);
+    const filePath = path7.resolve(opts.profile);
     let raw;
     try {
       raw = await fs8.readFile(filePath, "utf8");
@@ -7683,6 +7667,391 @@ var WORDPRESS_CLI_COMMANDS = [
   }
 ];
 
+// src/commands/agent.ts
+import path6 from "path";
+function resolveStateDir(opts) {
+  if (opts?.stateDir) return opts.stateDir;
+  try {
+    const config = loadConfig();
+    const profile = config.agent?.profile ?? "aero";
+    return getAeroStateDir(profile);
+  } catch {
+    return getAeroStateDir();
+  }
+}
+function resolveConfig() {
+  try {
+    return loadConfig().agent ?? {};
+  } catch {
+    return {};
+  }
+}
+async function agentStatus(opts) {
+  const stateDir = resolveStateDir(opts);
+  const config = resolveConfig();
+  const mgr = new AgentManager(config, stateDir);
+  const status = mgr.status();
+  if (opts?.format === "json") {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  if (status.state === "running") {
+    console.log(`Agent: running (PID ${status.pid}, port ${status.port})`);
+    if (status.startedAt) {
+      console.log(`Started: ${status.startedAt}`);
+    }
+  } else {
+    console.log("Agent: stopped");
+  }
+}
+async function agentStart(opts) {
+  const stateDir = resolveStateDir(opts);
+  const config = resolveConfig();
+  const mgr = new AgentManager(config, stateDir);
+  await mgr.start();
+  const status = mgr.status();
+  if (opts?.format === "json") {
+    console.log(JSON.stringify(status, null, 2));
+  } else {
+    console.log(`Agent started (PID ${status.pid}, port ${status.port})`);
+  }
+}
+async function agentStop(opts) {
+  const stateDir = resolveStateDir(opts);
+  const config = resolveConfig();
+  const mgr = new AgentManager(config, stateDir);
+  await mgr.stop();
+  if (opts?.format === "json") {
+    console.log(JSON.stringify({ state: "stopped" }, null, 2));
+  } else {
+    console.log("Agent stopped");
+  }
+}
+async function agentReset(opts) {
+  const stateDir = resolveStateDir(opts);
+  const config = resolveConfig();
+  const mgr = new AgentManager(config, stateDir);
+  await mgr.reset();
+  if (opts?.format === "json") {
+    console.log(JSON.stringify({ state: "reset" }, null, 2));
+  } else {
+    console.log('Agent reset \u2014 workspace wiped. Run "canonry agent setup" to re-initialize.');
+  }
+}
+async function agentSetup(opts) {
+  const isJson = opts?.format === "json";
+  let agentLLM;
+  if (!configExists()) {
+    const initOpts = {
+      geminiKey: opts?.geminiKey,
+      openaiKey: opts?.openaiKey,
+      claudeKey: opts?.claudeKey,
+      perplexityKey: opts?.perplexityKey,
+      localUrl: opts?.localUrl,
+      localModel: opts?.localModel,
+      localKey: opts?.localKey,
+      googleClientId: opts?.googleClientId,
+      googleClientSecret: opts?.googleClientSecret,
+      agentProvider: opts?.agentProvider,
+      agentKey: opts?.agentKey,
+      agentModel: opts?.agentModel
+    };
+    if (isJson) {
+      agentLLM = await suppressStdout(() => initCommand(initOpts)) ?? void 0;
+    } else {
+      agentLLM = await initCommand(initOpts) ?? void 0;
+    }
+  }
+  const existingConfig = resolveConfig();
+  let detection = await detectOpenClaw(existingConfig);
+  if (!detection.found) {
+    detection = await autoInstallOrFail(opts?.format);
+  }
+  const profile = existingConfig.profile ?? "aero";
+  const gatewayPort = opts?.gatewayPort ?? existingConfig.gatewayPort ?? 3579;
+  const stateDir = opts?.stateDir ?? getAeroStateDir(profile);
+  saveConfigPatch({
+    agent: {
+      binary: detection.path,
+      profile,
+      gatewayPort,
+      autoStart: existingConfig.autoStart
+    }
+  });
+  initializeOpenClawProfile(detection.path, profile, path6.join(stateDir, "workspace"));
+  configureOpenClawGateway(detection.path, profile, gatewayPort);
+  const creds = agentLLM ?? resolveAgentCredentials({
+    agentProvider: opts?.agentProvider,
+    agentKey: opts?.agentKey,
+    agentModel: opts?.agentModel,
+    stateDir
+  });
+  if (creds.key) {
+    writeAgentEnv(stateDir, providerEnvVar(creds.provider), creds.key);
+    if (opts?.format !== "json") {
+      console.log(`Agent LLM: ${creds.provider} credentials configured`);
+    }
+  }
+  if (creds.model) {
+    setOpenClawModel(detection.path, profile, creds.model);
+    if (opts?.format !== "json") {
+      console.log(`Agent model: ${creds.model}`);
+    }
+  }
+  seedWorkspace(stateDir);
+  const attachSummary = await attachAgentWebhookToAllProjects(gatewayPort);
+  if (opts?.format === "json") {
+    console.log(JSON.stringify({
+      state: "configured",
+      binary: detection.path,
+      version: detection.version,
+      profile,
+      gatewayPort,
+      stateDir,
+      attached: attachSummary
+    }, null, 2));
+  } else {
+    console.log(`OpenClaw: ${detection.path} (${detection.version})`);
+    console.log(`Profile: ${profile}`);
+    console.log(`Gateway port: ${gatewayPort}`);
+    console.log(`State dir: ${stateDir}`);
+    if (attachSummary.attached > 0 || attachSummary.alreadyAttached > 0) {
+      console.log(
+        `Agent webhook: ${attachSummary.attached} attached, ${attachSummary.alreadyAttached} already present (via ${attachSummary.path})`
+      );
+    }
+    console.log("Agent setup complete.");
+  }
+}
+async function attachAgentWebhookToAllProjects(gatewayPort) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    return { path: "skipped", attached: 0, alreadyAttached: 0 };
+  }
+  try {
+    const client = createApiClient();
+    const projectList = await client.listProjects();
+    const agentUrl = buildAgentWebhookUrl(gatewayPort);
+    let attached2 = 0;
+    let alreadyAttached2 = 0;
+    for (const project of projectList) {
+      const existing = await client.listNotifications(project.name);
+      if (existing.some((n) => n.source === "agent")) {
+        alreadyAttached2++;
+        continue;
+      }
+      await client.createNotification(project.name, {
+        channel: "webhook",
+        url: agentUrl,
+        events: [...AGENT_WEBHOOK_EVENTS],
+        source: "agent"
+      });
+      attached2++;
+    }
+    return { path: "api", attached: attached2, alreadyAttached: alreadyAttached2 };
+  } catch (err) {
+    if (!isConnectionError(err)) throw err;
+  }
+  const db = createClient(config.database);
+  migrate(db);
+  const rows = db.select({ id: projects.id }).from(projects).all();
+  let attached = 0;
+  let alreadyAttached = 0;
+  for (const row of rows) {
+    const result = attachAgentWebhookDirect(db, row.id, gatewayPort);
+    if (result === "attached") attached++;
+    else alreadyAttached++;
+  }
+  return { path: "db", attached, alreadyAttached };
+}
+function isConnectionError(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  const code = err.code ?? "";
+  return code === "CONNECTION_ERROR" || code === "ECONNREFUSED" || code === "ENOTFOUND" || msg.includes("could not connect") || msg.includes("econnrefused") || msg.includes("fetch failed") || msg.includes("connection refused");
+}
+async function agentAttach(opts) {
+  const config = loadConfig();
+  const gatewayPort = config.agent?.gatewayPort ?? 3579;
+  const agentUrl = buildAgentWebhookUrl(gatewayPort);
+  const client = createApiClient();
+  const existing = await client.listNotifications(opts.project);
+  const hasAgent = existing.some((n) => n.source === "agent");
+  if (hasAgent) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify({ status: "already-attached", project: opts.project }));
+    } else {
+      console.log(`Agent webhook already attached to "${opts.project}"`);
+    }
+    return;
+  }
+  const result = await client.createNotification(opts.project, {
+    channel: "webhook",
+    url: agentUrl,
+    events: [...AGENT_WEBHOOK_EVENTS],
+    source: "agent"
+  });
+  if (opts.format === "json") {
+    console.log(JSON.stringify({ status: "attached", project: opts.project, notificationId: result.id }));
+  } else {
+    console.log(`Agent webhook attached to "${opts.project}"`);
+  }
+}
+async function agentDetach(opts) {
+  const client = createApiClient();
+  const existing = await client.listNotifications(opts.project);
+  const agentNotif = existing.find((n) => n.source === "agent");
+  if (!agentNotif) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify({ status: "not-attached", project: opts.project }));
+    } else {
+      console.log(`No agent webhook found on "${opts.project}"`);
+    }
+    return;
+  }
+  await client.deleteNotification(opts.project, agentNotif.id);
+  if (opts.format === "json") {
+    console.log(JSON.stringify({ status: "detached", project: opts.project }));
+  } else {
+    console.log(`Agent webhook detached from "${opts.project}"`);
+  }
+}
+async function autoInstallOrFail(format) {
+  if (format !== "json") {
+    console.log("OpenClaw not found, installing via npm...");
+  }
+  const install = await installOpenClaw({ silent: format === "json" });
+  if (!install.success) {
+    const msg = `Failed to install OpenClaw: ${install.error}`;
+    if (format === "json") {
+      console.error(JSON.stringify({ error: { code: "AGENT_INSTALL_FAILED", message: msg } }));
+    } else {
+      console.error(msg);
+    }
+    process.exitCode = 1;
+    throw new Error(msg);
+  }
+  if (format !== "json") {
+    console.log(`Installed OpenClaw ${install.detection.version}`);
+  }
+  return install.detection;
+}
+async function suppressStdout(fn) {
+  const original = console.log;
+  console.log = () => {
+  };
+  try {
+    return await fn();
+  } finally {
+    console.log = original;
+  }
+}
+
+// src/cli-commands/agent.ts
+var AGENT_CLI_COMMANDS = [
+  {
+    path: ["agent", "status"],
+    usage: "canonry agent status [--format json]",
+    options: {},
+    run: async (input) => {
+      await agentStatus({ format: input.format });
+    }
+  },
+  {
+    path: ["agent", "start"],
+    usage: "canonry agent start [--format json]",
+    options: {},
+    run: async (input) => {
+      await agentStart({ format: input.format });
+    }
+  },
+  {
+    path: ["agent", "stop"],
+    usage: "canonry agent stop [--format json]",
+    options: {},
+    run: async (input) => {
+      await agentStop({ format: input.format });
+    }
+  },
+  {
+    path: ["agent", "reset"],
+    usage: "canonry agent reset [--format json]",
+    options: {},
+    run: async (input) => {
+      await agentReset({ format: input.format });
+    }
+  },
+  {
+    path: ["agent", "attach"],
+    usage: "canonry agent attach <project> [--format json]",
+    options: {},
+    run: async (input) => {
+      const project = input.positionals[0];
+      if (!project) {
+        console.error("Usage: canonry agent attach <project>");
+        process.exitCode = 1;
+        return;
+      }
+      await agentAttach({ project, format: input.format });
+    }
+  },
+  {
+    path: ["agent", "detach"],
+    usage: "canonry agent detach <project> [--format json]",
+    options: {},
+    run: async (input) => {
+      const project = input.positionals[0];
+      if (!project) {
+        console.error("Usage: canonry agent detach <project>");
+        process.exitCode = 1;
+        return;
+      }
+      await agentDetach({ project, format: input.format });
+    }
+  },
+  {
+    path: ["agent", "setup"],
+    usage: "canonry agent setup [--agent-provider <id>] [--agent-key <key>] [--agent-model <model>] [--gateway-port <port>] [--gemini-key <key>] [--openai-key <key>] [--claude-key <key>] [--perplexity-key <key>] [--format json]",
+    options: {
+      "agent-provider": stringOption(),
+      "agent-key": stringOption(),
+      "agent-model": stringOption(),
+      "gateway-port": { type: "string" },
+      "gemini-key": stringOption(),
+      "openai-key": stringOption(),
+      "claude-key": stringOption(),
+      "perplexity-key": stringOption(),
+      "local-url": stringOption(),
+      "local-model": stringOption(),
+      "local-key": stringOption(),
+      "google-client-id": stringOption(),
+      "google-client-secret": stringOption()
+    },
+    run: async (input) => {
+      const portStr = input.values["gateway-port"];
+      const gatewayPort = typeof portStr === "string" ? Number.parseInt(portStr, 10) : void 0;
+      await agentSetup({
+        agentProvider: getString(input.values, "agent-provider"),
+        agentKey: getString(input.values, "agent-key"),
+        agentModel: getString(input.values, "agent-model"),
+        gatewayPort,
+        format: input.format,
+        geminiKey: getString(input.values, "gemini-key"),
+        openaiKey: getString(input.values, "openai-key"),
+        claudeKey: getString(input.values, "claude-key"),
+        perplexityKey: getString(input.values, "perplexity-key"),
+        localUrl: getString(input.values, "local-url"),
+        localModel: getString(input.values, "local-model"),
+        localKey: getString(input.values, "local-key"),
+        googleClientId: getString(input.values, "google-client-id"),
+        googleClientSecret: getString(input.values, "google-client-secret")
+      });
+    }
+  }
+];
+
 // src/cli-commands.ts
 var REGISTERED_CLI_COMMANDS = [
   ...BACKFILL_CLI_COMMANDS,
@@ -7701,7 +8070,8 @@ var REGISTERED_CLI_COMMANDS = [
   ...WORDPRESS_CLI_COMMANDS,
   ...CDP_CLI_COMMANDS,
   ...GA_CLI_COMMANDS,
-  ...INTELLIGENCE_CLI_COMMANDS
+  ...INTELLIGENCE_CLI_COMMANDS,
+  ...AGENT_CLI_COMMANDS
 ];
 
 // src/cli.ts

package/dist/index.d.ts

@@ -73,6 +73,16 @@ interface WordpressConnectionConfigEntry {
 interface WordpressConfigEntry {
     connections?: WordpressConnectionConfigEntry[];
 }
+interface AgentConfigEntry {
+    /** Path to openclaw binary (auto-detected, persisted after bootstrap) */
+    binary?: string;
+    /** OpenClaw profile name (default: 'aero') */
+    profile?: string;
+    /** Start gateway automatically with `canonry serve` */
+    autoStart?: boolean;
+    /** Gateway port (persisted so restarts reuse same port) */
+    gatewayPort?: number;
+}
 interface CanonryConfig {
     apiUrl: string;
     publicUrl?: string;
@@ -93,6 +103,7 @@ interface CanonryConfig {
     dashboardPasswordHash?: string;
     telemetry?: boolean;
     anonymousId?: string;
+    agent?: AgentConfigEntry;
 }
 declare function loadConfig(): CanonryConfig;
 

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createServer,
   loadConfig
-} from "./chunk-22RIKNII.js";
+} from "./chunk-25QLMK4F.js";
 import "./chunk-HO22LHTY.js";
 export {
   createServer,