@ainyc/canonry 1.46.0 → 1.46.1

package/dist/cli.js

@@ -28,11 +28,12 @@ import {
   setGoogleAuthConfig,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-22RIKNII.js";
+} from "./chunk-RMLIF47M.js";
 import {
   apiKeys,
   competitors,
   createClient,
+  createLogger,
   migrate,
   parseJsonColumn,
   projects,
@@ -118,9 +119,9 @@ 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, path9) {
+  if (args.length < path9.length) return false;
+  return path9.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -613,9 +614,9 @@ var ApiClient = class {
     }
     return this.probePromise;
   }
-  async request(method, path6, body) {
+  async request(method, path9, body) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path6}`;
+    const url = `${this.baseUrl}${path9}`;
     const serializedBody = body != null ? JSON.stringify(body) : void 0;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
@@ -1694,9 +1695,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs8 = await import("fs");
+    const fs10 = await import("fs");
     try {
-      const content = fs8.readFileSync(opts.keyFile, "utf-8");
+      const content = fs10.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -2454,10 +2455,10 @@ Open this URL in your browser to authorize Google ${opts.type.toUpperCase()} acc
     console.log("(Ensure this URI is listed in your Google Cloud Console OAuth client's authorized redirect URIs)\n");
   }
   try {
-    const { spawn: spawn2 } = await import("child_process");
+    const { spawn: spawn3 } = await import("child_process");
     const platform = process.platform;
     const [cmd, ...extraArgs] = platform === "darwin" ? ["open", authUrl] : platform === "win32" ? ["cmd", "/c", "start", "", authUrl] : ["xdg-open", authUrl];
-    spawn2(cmd, [...extraArgs], { detached: true, stdio: "ignore" }).unref();
+    spawn3(cmd, [...extraArgs], { detached: true, stdio: "ignore" }).unref();
     console.log("(Browser opened automatically)");
   } catch {
     console.log("(Could not open browser automatically \u2014 please copy the URL above)");
@@ -6142,6 +6143,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 +6164,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 +6323,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 +6354,7 @@ Config saved to ${getConfigPath()}`);
     providerCount: providerNames.length,
     providers: providerNames
   });
+  return agentLLM;
 }
 
 // src/commands/serve.ts
@@ -6883,12 +6917,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs8 = await import("fs/promises");
-  const path6 = await import("path");
-  const filePath = path6.resolve(opts.from);
+  const fs10 = await import("fs/promises");
+  const path9 = await import("path");
+  const filePath = path9.resolve(opts.from);
   let raw;
   try {
-    raw = await fs8.readFile(filePath, "utf8");
+    raw = await fs10.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -6985,13 +7019,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs8 = await import("fs/promises");
-  const path6 = await import("path");
+  const fs10 = await import("fs/promises");
+  const path9 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path6.resolve(opts.profile);
+  const filePath = path9.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs8.readFile(filePath, "utf8");
+    raw = await fs10.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -7096,13 +7130,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs8 = await import("fs/promises");
-    const path6 = await import("path");
+    const fs10 = await import("fs/promises");
+    const path9 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path6.resolve(opts.profile);
+    const filePath = path9.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs8.readFile(filePath, "utf8");
+      raw = await fs10.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -7683,6 +7717,699 @@ var WORDPRESS_CLI_COMMANDS = [
   }
 ];
 
+// src/commands/agent.ts
+import path8 from "path";
+
+// src/agent-manager.ts
+import { execFileSync, spawn as spawn2 } from "child_process";
+import fs8 from "fs";
+import path6 from "path";
+var log = createLogger("AgentManager");
+var PROCESS_MARKER = "canonry-openclaw-gateway";
+var AgentManager = class {
+  constructor(config, stateDir) {
+    this.config = config;
+    this.stateDir = stateDir;
+    this.processJsonPath = path6.join(stateDir, "process.json");
+  }
+  processJsonPath;
+  /**
+   * Check if the gateway process is running.
+   * Cleans up stale process.json if the process is dead or belongs to a
+   * different process (PID reuse).
+   */
+  status() {
+    const info = this.readProcessInfo();
+    if (!info) {
+      return { state: "stopped" };
+    }
+    if (info.marker !== PROCESS_MARKER) {
+      this.removeProcessJson();
+      return { state: "stopped" };
+    }
+    if (isProcessAlive2(info.pid) && this.verifyProcessIdentity(info.pid)) {
+      return {
+        state: "running",
+        pid: info.pid,
+        port: info.gatewayPort,
+        startedAt: info.startedAt
+      };
+    }
+    this.removeProcessJson();
+    return { state: "stopped" };
+  }
+  /**
+   * Start the OpenClaw gateway as a detached background process.
+   * Idempotent — no-op if already running.
+   * Waits briefly for the process to confirm it hasn't crashed on startup.
+   */
+  async start() {
+    const currentStatus = this.status();
+    if (currentStatus.state === "running") {
+      log.info("already.running", { pid: currentStatus.pid });
+      return;
+    }
+    const binary = this.config.binary ?? "openclaw";
+    const profile = this.config.profile ?? "aero";
+    const port = this.config.gatewayPort ?? 3579;
+    if (!fs8.existsSync(this.stateDir)) {
+      fs8.mkdirSync(this.stateDir, { recursive: true });
+    }
+    const logFile = path6.join(this.stateDir, "gateway.log");
+    const logFd = fs8.openSync(logFile, "a");
+    const dotEnv = this.loadDotEnv();
+    const child = spawn2(binary, ["--profile", profile, "gateway"], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: {
+        ...process.env,
+        ...dotEnv,
+        OPENCLAW_PROFILE: profile,
+        OPENCLAW_GATEWAY_PORT: String(port),
+        OPENCLAW_STATE_DIR: this.stateDir
+      }
+    });
+    const startupResult = await new Promise((resolve) => {
+      let settled = false;
+      const settle = (r) => {
+        if (settled) return;
+        settled = true;
+        resolve(r);
+      };
+      child.on("error", (err) => settle({ error: err }));
+      child.on("exit", (code) => settle({ exitCode: code }));
+      setTimeout(() => settle({}), 500);
+    });
+    child.unref();
+    fs8.closeSync(logFd);
+    if (startupResult.error) {
+      throw new Error(`Failed to start OpenClaw gateway: ${startupResult.error.message}`);
+    }
+    if (startupResult.exitCode != null) {
+      throw new Error(`OpenClaw gateway exited immediately (code ${startupResult.exitCode}). Check ${path6.join(this.stateDir, "gateway.log")} for details.`);
+    }
+    if (child.pid == null) {
+      throw new Error("Failed to start OpenClaw gateway: no PID returned by spawn");
+    }
+    if (!isProcessAlive2(child.pid)) {
+      throw new Error(`OpenClaw gateway exited immediately after spawn. Check ${path6.join(this.stateDir, "gateway.log")} for details.`);
+    }
+    const processInfo = {
+      pid: child.pid,
+      gatewayPort: port,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      marker: PROCESS_MARKER
+    };
+    fs8.writeFileSync(this.processJsonPath, JSON.stringify(processInfo, null, 2), "utf-8");
+    log.info("started", { pid: child.pid, port });
+  }
+  /**
+   * Stop the gateway process.
+   * Uses DenchClaw escalation: SIGTERM → 800ms poll → SIGKILL.
+   * Idempotent — no-op if already stopped.
+   */
+  async stop() {
+    const info = this.readProcessInfo();
+    if (!info) return;
+    if (isProcessAlive2(info.pid) && info.marker === PROCESS_MARKER && this.verifyProcessIdentity(info.pid)) {
+      await terminateWithEscalation(info.pid);
+    }
+    this.removeProcessJson();
+    log.info("stopped", { pid: info.pid });
+  }
+  /**
+   * Stop the gateway, wipe the workspace directory, and prepare for re-seeding.
+   */
+  async reset() {
+    await this.stop();
+    const workspaceDir = path6.join(this.stateDir, "workspace");
+    if (fs8.existsSync(workspaceDir)) {
+      fs8.rmSync(workspaceDir, { recursive: true, force: true });
+      log.info("workspace.wiped", { dir: workspaceDir });
+    }
+  }
+  /**
+   * Verify that the PID actually belongs to an openclaw process by checking
+   * the full command line. Requires "openclaw" in the args to avoid matching
+   * unrelated Node processes after PID reuse.
+   */
+  verifyProcessIdentity(pid) {
+    try {
+      if (process.platform === "darwin") {
+        const out = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+          encoding: "utf-8",
+          timeout: 2e3
+        }).trim();
+        return out.includes("openclaw");
+      }
+      if (process.platform === "linux") {
+        const cmdline = fs8.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+        return cmdline.includes("openclaw");
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  readProcessInfo() {
+    if (!fs8.existsSync(this.processJsonPath)) return null;
+    try {
+      return JSON.parse(fs8.readFileSync(this.processJsonPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  removeProcessJson() {
+    try {
+      fs8.unlinkSync(this.processJsonPath);
+    } catch {
+    }
+  }
+  /** Parse a simple KEY=value dotenv file from the state dir. */
+  loadDotEnv() {
+    const envFile = path6.join(this.stateDir, ".env");
+    if (!fs8.existsSync(envFile)) return {};
+    const result = {};
+    for (const line of fs8.readFileSync(envFile, "utf-8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq3 = trimmed.indexOf("=");
+      if (eq3 < 1) continue;
+      result[trimmed.slice(0, eq3)] = trimmed.slice(eq3 + 1);
+    }
+    return result;
+  }
+};
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function terminateWithEscalation(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 800;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive2(pid)) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+
+// src/agent-bootstrap.ts
+import { execFileSync as execFileSync2, execSync } from "child_process";
+import fs9 from "fs";
+import os from "os";
+import path7 from "path";
+import { fileURLToPath } from "url";
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var cachedResult = null;
+var cachedAt = 0;
+function getAeroStateDir(profile = "aero") {
+  return path7.join(os.homedir(), `.openclaw-${profile}`);
+}
+async function detectOpenClaw(config) {
+  if (cachedResult && Date.now() - cachedAt < CACHE_TTL_MS) {
+    return cachedResult;
+  }
+  let result;
+  if (config?.binary) {
+    const version = probeVersion(config.binary);
+    if (version) {
+      result = { found: true, path: config.binary, version };
+      cachedResult = result;
+      cachedAt = Date.now();
+      return result;
+    }
+  }
+  const binaryPath = findInPath();
+  if (binaryPath) {
+    const version = probeVersion(binaryPath);
+    if (version) {
+      result = { found: true, path: binaryPath, version };
+      cachedResult = result;
+      cachedAt = Date.now();
+      return result;
+    }
+  }
+  result = { found: false };
+  cachedResult = result;
+  cachedAt = Date.now();
+  return result;
+}
+detectOpenClaw.resetCache = () => {
+  cachedResult = null;
+  cachedAt = 0;
+};
+function probeVersion(binaryPath) {
+  try {
+    const output = execFileSync2(binaryPath, ["--version"], {
+      timeout: 5e3,
+      encoding: "utf-8"
+    });
+    const match = output.toString().trim().match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : output.toString().trim();
+  } catch {
+    return null;
+  }
+}
+function findInPath() {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const output = execFileSync2(cmd, ["openclaw"], {
+      timeout: 5e3,
+      encoding: "utf-8"
+    });
+    return output.toString().trim().split("\n")[0] || null;
+  } catch {
+    return null;
+  }
+}
+async function installOpenClaw(opts) {
+  try {
+    execSync("npm install -g openclaw", {
+      timeout: 12e4,
+      stdio: opts?.silent ? "pipe" : "inherit"
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  detectOpenClaw.resetCache();
+  const detection = await detectOpenClaw();
+  if (!detection.found) {
+    return {
+      success: false,
+      error: "npm install succeeded but openclaw binary was not found in PATH"
+    };
+  }
+  return { success: true, detection };
+}
+function seedWorkspace(stateDir) {
+  const workspaceDir = path7.join(stateDir, "workspace");
+  fs9.mkdirSync(workspaceDir, { recursive: true });
+  const __dirname = path7.dirname(fileURLToPath(import.meta.url));
+  const assetsDir = path7.join(__dirname, "..", "assets", "agent-workspace");
+  if (!fs9.existsSync(assetsDir)) {
+    return;
+  }
+  copyDirRecursive(assetsDir, workspaceDir);
+}
+function initializeOpenClawProfile(binary, profile, workspaceDir) {
+  try {
+    execFileSync2(binary, [
+      "--profile",
+      profile,
+      "onboard",
+      "--non-interactive",
+      "--accept-risk",
+      "--mode",
+      "local",
+      "--workspace",
+      workspaceDir,
+      "--skip-channels",
+      "--skip-skills",
+      "--skip-health",
+      "--no-install-daemon"
+    ], { timeout: 3e4, stdio: "pipe" });
+  } catch (err) {
+    const stderr = err instanceof Error && "stderr" in err ? String(err.stderr) : "";
+    if (stderr.toLowerCase().includes("already")) return;
+    throw new CliError({
+      code: "AGENT_PROFILE_INIT_FAILED",
+      message: `Failed to initialize OpenClaw profile: ${stderr || (err instanceof Error ? err.message : String(err))}`,
+      displayMessage: `Failed to initialize OpenClaw profile "${profile}".`
+    });
+  }
+}
+function configureOpenClawGateway(binary, profile, gatewayPort) {
+  const entries = [
+    ["gateway.mode", "local", false],
+    ["gateway.port", String(gatewayPort), true]
+  ];
+  for (const [key, value, strict] of entries) {
+    try {
+      const args = ["--profile", profile, "config", "set", key, value];
+      if (strict) args.push("--strict-json");
+      execFileSync2(binary, args, { timeout: 1e4, stdio: "pipe" });
+    } catch (err) {
+      throw new CliError({
+        code: "AGENT_GATEWAY_CONFIG_FAILED",
+        message: `Failed to set ${key}=${value}: ${err instanceof Error ? err.message : String(err)}`,
+        displayMessage: `Failed to configure OpenClaw gateway (${key}).`
+      });
+    }
+  }
+}
+function setOpenClawModel(binary, profile, model) {
+  try {
+    execFileSync2(binary, [
+      "--profile",
+      profile,
+      "models",
+      "set",
+      model
+    ], { timeout: 1e4, stdio: "pipe" });
+  } catch (err) {
+    throw new CliError({
+      code: "AGENT_MODEL_SET_FAILED",
+      message: `Failed to set agent model to ${model}: ${err instanceof Error ? err.message : String(err)}`,
+      displayMessage: `Failed to set agent model to "${model}".`
+    });
+  }
+}
+function providerEnvVar(provider) {
+  const map = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    google: "GOOGLE_API_KEY",
+    "google-vertex": "GOOGLE_API_KEY",
+    groq: "GROQ_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    xai: "XAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    cerebras: "CEREBRAS_API_KEY"
+  };
+  return map[provider] ?? `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+}
+function writeAgentEnv(stateDir, key, value) {
+  const envFile = path7.join(stateDir, ".env");
+  let lines = [];
+  if (fs9.existsSync(envFile)) {
+    lines = fs9.readFileSync(envFile, "utf-8").split("\n");
+  }
+  const prefix = `${key}=`;
+  const idx = lines.findIndex((l) => l.startsWith(prefix));
+  const entry = `${key}=${value}`;
+  if (idx >= 0) {
+    lines[idx] = entry;
+  } else {
+    lines.push(entry);
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  fs9.writeFileSync(envFile, lines.join("\n") + "\n", "utf-8");
+}
+function resolveAgentCredentials(opts) {
+  const provider = opts.agentProvider ?? "anthropic";
+  if (opts.agentKey) {
+    return { provider, key: opts.agentKey, model: opts.agentModel };
+  }
+  const envVar = providerEnvVar(provider);
+  const envKey = process.env[envVar];
+  if (envKey) {
+    return { provider, key: envKey, model: opts.agentModel };
+  }
+  const genericKey = process.env.CANONRY_AGENT_KEY;
+  if (genericKey) {
+    return { provider, key: genericKey, model: opts.agentModel };
+  }
+  const envFile = path7.join(opts.stateDir, ".env");
+  if (fs9.existsSync(envFile)) {
+    const hasKey = fs9.readFileSync(envFile, "utf-8").split("\n").some((l) => l.includes("_API_KEY="));
+    if (hasKey) {
+      return { provider, key: void 0, model: opts.agentModel };
+    }
+  }
+  return { provider, key: void 0, model: opts.agentModel };
+}
+function copyDirRecursive(src, dest) {
+  fs9.mkdirSync(dest, { recursive: true });
+  for (const entry of fs9.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path7.join(src, entry.name);
+    const destPath = path7.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs9.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/agent.ts
+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, path8.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);
+  if (opts?.format === "json") {
+    console.log(JSON.stringify({
+      state: "configured",
+      binary: detection.path,
+      version: detection.version,
+      profile,
+      gatewayPort,
+      stateDir
+    }, null, 2));
+  } else {
+    console.log(`OpenClaw: ${detection.path} (${detection.version})`);
+    console.log(`Profile: ${profile}`);
+    console.log(`Gateway port: ${gatewayPort}`);
+    console.log(`State dir: ${stateDir}`);
+    console.log("Agent setup complete.");
+  }
+}
+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", "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 +8428,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