@ainyc/canonry 1.10.0 → 1.11.0

package/dist/cli.js

@@ -16,9 +16,10 @@ import {
   notificationEventSchema,
   providerQuotaPolicySchema,
   saveConfig,
+  setGoogleAuthConfig,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-P4D4VWJQ.js";
+} from "./chunk-MVIL2UGM.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
@@ -67,7 +68,9 @@ var bootstrapEnvSchema = z.object({
   ANTHROPIC_MODEL: z.string().optional(),
   LOCAL_BASE_URL: z.string().optional(),
   LOCAL_API_KEY: z.string().optional(),
-  LOCAL_MODEL: z.string().optional()
+  LOCAL_MODEL: z.string().optional(),
+  GOOGLE_CLIENT_ID: z.string().optional(),
+  GOOGLE_CLIENT_SECRET: z.string().optional()
 });
 function getBootstrapEnv(source, overrides) {
   const filtered = overrides ? Object.fromEntries(Object.entries(overrides).filter(([, v]) => v != null)) : {};
@@ -122,6 +125,8 @@ function getBootstrapEnv(source, overrides) {
     apiKey: parsed.CANONRY_API_KEY,
     apiUrl: parsed.CANONRY_API_URL,
     databasePath: parsed.CANONRY_DATABASE_PATH,
+    googleClientId: parsed.GOOGLE_CLIENT_ID,
+    googleClientSecret: parsed.GOOGLE_CLIENT_SECRET,
     providers
   };
 }
@@ -155,6 +160,14 @@ async function bootstrapCommand(_opts) {
   if (providers?.openai) mergedProviders.openai = providers.openai;
   if (providers?.claude) mergedProviders.claude = providers.claude;
   if (providers?.local) mergedProviders.local = providers.local;
+  if (env.googleClientId && !env.googleClientSecret || !env.googleClientId && env.googleClientSecret) {
+    console.warn("Warning: GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET must both be set to configure Google OAuth. Skipping Google auth config.");
+  }
+  const mergedGoogle = env.googleClientId && env.googleClientSecret ? {
+    clientId: env.googleClientId,
+    clientSecret: env.googleClientSecret,
+    connections: existingConfig?.google?.connections ?? []
+  } : existingConfig?.google;
   const keyHash = crypto.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
   const db = createClient(databasePath);
@@ -172,7 +185,8 @@ async function bootstrapCommand(_opts) {
     apiUrl: env.apiUrl || existingConfig?.apiUrl || `http://localhost:${process.env.CANONRY_PORT || "4100"}`,
     database: databasePath,
     apiKey: rawApiKey,
-    providers: mergedProviders
+    providers: mergedProviders,
+    google: mergedGoogle
   });
   console.log(`Bootstrap complete. Config saved to ${getConfigPath()}`);
   console.log(`SQLite database path: ${databasePath}`);
@@ -214,23 +228,40 @@ async function initCommand(opts) {
   if (!fs.existsSync(configDir)) {
     fs.mkdirSync(configDir, { recursive: true });
   }
-  const envProviders = getBootstrapEnv(process.env, {
+  const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
     OPENAI_API_KEY: opts?.openaiKey,
     ANTHROPIC_API_KEY: opts?.claudeKey,
     LOCAL_BASE_URL: opts?.localUrl,
     LOCAL_MODEL: opts?.localModel,
-    LOCAL_API_KEY: opts?.localKey
-  }).providers;
-  const nonInteractive = !!(envProviders.gemini || envProviders.openai || envProviders.claude || envProviders.local);
+    LOCAL_API_KEY: opts?.localKey,
+    GOOGLE_CLIENT_ID: opts?.googleClientId,
+    GOOGLE_CLIENT_SECRET: opts?.googleClientSecret
+  });
+  if (bootstrapEnv.googleClientId && !bootstrapEnv.googleClientSecret || !bootstrapEnv.googleClientId && bootstrapEnv.googleClientSecret) {
+    console.error("Google OAuth requires both a client ID and client secret when configured non-interactively.");
+    process.exit(1);
+  }
+  const envProviders = bootstrapEnv.providers;
+  const envGoogleConfigured = !!(bootstrapEnv.googleClientId && bootstrapEnv.googleClientSecret);
+  const nonInteractive = !!(envProviders.gemini || envProviders.openai || envProviders.claude || envProviders.local || envGoogleConfigured);
   const providers = {};
+  let google;
   if (nonInteractive) {
     Object.assign(providers, envProviders);
+    if (envGoogleConfigured) {
+      google = {
+        clientId: bootstrapEnv.googleClientId,
+        clientSecret: bootstrapEnv.googleClientSecret,
+        connections: []
+      };
+    }
   } else {
     console.log("Configure AI providers (at least one required):\n");
-    console.log("Tip: For non-interactive setup, pass --gemini-key, --openai-key,");
-    console.log("--claude-key flags or set GEMINI_API_KEY, OPENAI_API_KEY,");
-    console.log('ANTHROPIC_API_KEY env vars. Or use "canonry bootstrap".\n');
+    console.log("Tip: For non-interactive setup, pass provider flags or set");
+    console.log("GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY,");
+    console.log("GOOGLE_CLIENT_ID, and GOOGLE_CLIENT_SECRET env vars.");
+    console.log('Or use "canonry bootstrap".\n');
     const geminiApiKey = await prompt("Gemini API key (press Enter to skip): ");
     if (geminiApiKey) {
       const geminiModel = await prompt("  Gemini model [gemini-2.5-flash]: ") || "gemini-2.5-flash";
@@ -253,6 +284,20 @@ async function initCommand(opts) {
       const localApiKey = await prompt("  API key (press Enter if not needed): ") || void 0;
       providers.local = { baseUrl: localBaseUrl, apiKey: localApiKey, model: localModel, quota: DEFAULT_QUOTA };
     }
+    console.log("\nGoogle Search Console OAuth (optional):");
+    const googleClientId = await prompt("Google OAuth client ID (press Enter to skip): ");
+    if (googleClientId) {
+      const googleClientSecret = await prompt("  Google OAuth client secret: ");
+      if (!googleClientSecret) {
+        console.error("\nGoogle OAuth client secret is required when a client ID is provided.");
+        process.exit(1);
+      }
+      google = {
+        clientId: googleClientId,
+        clientSecret: googleClientSecret,
+        connections: []
+      };
+    }
   }
   const hasProvider = providers.gemini || providers.openai || providers.claude || providers.local;
   if (!hasProvider) {
@@ -277,7 +322,8 @@ async function initCommand(opts) {
     apiUrl: "http://localhost:4100",
     database: databasePath,
     apiKey: rawApiKey,
-    providers
+    providers,
+    google
   });
   const providerNames = Object.keys(providers);
   console.log(`
@@ -556,6 +602,40 @@ var ApiClient = class {
       { provider, count }
     );
   }
+  // Google connection management
+  async googleConnect(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/connect`, body);
+  }
+  async googleConnections(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/connections`);
+  }
+  async googleDisconnect(project, type) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/google/connections/${encodeURIComponent(type)}`);
+  }
+  async googleProperties(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/properties`);
+  }
+  async googleSetProperty(project, type, propertyId) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/google/connections/${encodeURIComponent(type)}/property`, { propertyId });
+  }
+  // GSC data
+  async gscSync(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/sync`, body ?? {});
+  }
+  async gscPerformance(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/performance${qs}`);
+  }
+  async gscInspect(project, url) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/inspect`, { url });
+  }
+  async gscInspections(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/inspections${qs}`);
+  }
+  async gscDeindexed(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/deindexed`);
+  }
 };
 
 // src/commands/project.ts
@@ -1071,9 +1151,15 @@ async function setProvider(name, opts) {
 }
 async function showSettings(format) {
   const client = getClient8();
+  const config = loadConfig();
   const settings = await client.getSettings();
   if (format === "json") {
-    console.log(JSON.stringify(settings, null, 2));
+    console.log(JSON.stringify({
+      ...settings,
+      google: {
+        configured: Boolean(config.google?.clientId && config.google?.clientSecret)
+      }
+    }, null, 2));
     return;
   }
   console.log("Provider settings:\n");
@@ -1087,6 +1173,18 @@ async function showSettings(format) {
       }
     }
   }
+  console.log("\nGoogle OAuth:\n");
+  console.log(`  ${config.google?.clientId && config.google?.clientSecret ? "configured" : "not configured"}`);
+}
+function setGoogleAuth(opts) {
+  const config = loadConfig();
+  setGoogleAuthConfig(config, {
+    clientId: opts.clientId,
+    clientSecret: opts.clientSecret
+  });
+  saveConfig(config);
+  console.log(`Google OAuth credentials saved to ${getConfigPath()}.`);
+  console.log("Restart the local server if it is already running.");
 }
 
 // src/commands/schedule.ts
@@ -1286,6 +1384,216 @@ function telemetryCommand(subcommand) {
   }
 }
 
+// src/commands/google.ts
+function getClient11() {
+  const config = loadConfig();
+  return new ApiClient(config.apiUrl, config.apiKey);
+}
+async function googleConnect(project, opts) {
+  const client = getClient11();
+  const { authUrl } = await client.googleConnect(project, { type: opts.type });
+  console.log(`
+Open this URL in your browser to authorize Google ${opts.type.toUpperCase()} access:
+`);
+  console.log(`  ${authUrl}
+`);
+  try {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} "${authUrl}"`);
+    console.log("(Browser opened automatically)");
+  } catch {
+    console.log("(Could not open browser automatically \u2014 please copy the URL above)");
+  }
+}
+async function googleDisconnect(project, opts) {
+  const client = getClient11();
+  await client.googleDisconnect(project, opts.type);
+  console.log(`Disconnected Google ${opts.type.toUpperCase()} from project "${project}".`);
+}
+async function googleStatus(project, format) {
+  const client = getClient11();
+  const connections = await client.googleConnections(project);
+  if (format === "json") {
+    console.log(JSON.stringify({ connections }, null, 2));
+    return;
+  }
+  if (connections.length === 0) {
+    console.log(`No Google connections for project "${project}".`);
+    console.log('Run "canonry google connect <project> --type gsc" to connect.');
+    return;
+  }
+  console.log(`Google connections for "${project}":
+`);
+  for (const conn of connections) {
+    const type = conn.connectionType.toUpperCase();
+    const property = conn.propertyId ?? "(not set)";
+    console.log(`  ${type}`);
+    console.log(`    Property:   ${property}`);
+    console.log(`    Connected:  ${conn.createdAt}`);
+    console.log(`    Updated:    ${conn.updatedAt}`);
+    console.log();
+  }
+}
+async function googleProperties(project, format) {
+  const client = getClient11();
+  const { sites } = await client.googleProperties(project);
+  if (format === "json") {
+    console.log(JSON.stringify({ sites }, null, 2));
+    return;
+  }
+  if (sites.length === 0) {
+    console.log("No verified sites found for this Google account.");
+    return;
+  }
+  console.log("Available GSC properties:\n");
+  const urlWidth = Math.max(10, ...sites.map((s) => s.siteUrl.length));
+  console.log(`  ${"SITE URL".padEnd(urlWidth)}  PERMISSION`);
+  console.log(`  ${"\u2500".repeat(urlWidth)}  ${"\u2500".repeat(12)}`);
+  for (const site of sites) {
+    console.log(`  ${site.siteUrl.padEnd(urlWidth)}  ${site.permissionLevel}`);
+  }
+  console.log(`
+Use "canonry google set-property <project> <siteUrl>" to select a property.`);
+}
+async function googleSetProperty(project, propertyUrl) {
+  const client = getClient11();
+  await client.googleSetProperty(project, "gsc", propertyUrl);
+  console.log(`GSC property set to "${propertyUrl}" for project "${project}".`);
+}
+async function googleSync(project, opts) {
+  const client = getClient11();
+  const run = await client.gscSync(project, { days: opts.days, full: opts.full });
+  if (opts.format === "json") {
+    console.log(JSON.stringify(run, null, 2));
+    return;
+  }
+  console.log(`GSC sync started (run ${run.id})`);
+  if (opts.wait) {
+    const timeout = 10 * 60 * 1e3;
+    const start = Date.now();
+    process.stderr.write("Waiting for sync to complete");
+    while (Date.now() - start < timeout) {
+      await new Promise((r) => setTimeout(r, 2e3));
+      const current = await client.getRun(run.id);
+      process.stderr.write(".");
+      if (current.status === "completed" || current.status === "failed") {
+        process.stderr.write("\n");
+        if (current.status === "completed") {
+          console.log("GSC sync completed successfully.");
+        } else {
+          console.error("GSC sync failed.");
+        }
+        return;
+      }
+    }
+    process.stderr.write("\n");
+    console.error("Timed out waiting for GSC sync to complete.");
+    process.exit(1);
+  }
+}
+async function googlePerformance(project, opts) {
+  const client = getClient11();
+  const params = {};
+  if (opts.days) {
+    const end = /* @__PURE__ */ new Date();
+    const start = /* @__PURE__ */ new Date();
+    start.setDate(start.getDate() - opts.days);
+    params.startDate = start.toISOString().split("T")[0];
+    params.endDate = end.toISOString().split("T")[0];
+  }
+  if (opts.keyword) params.query = opts.keyword;
+  if (opts.page) params.page = opts.page;
+  const rows = await client.gscPerformance(project, Object.keys(params).length > 0 ? params : void 0);
+  if (opts.format === "json") {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log('No GSC data found. Run "canonry google sync" first.');
+    return;
+  }
+  console.log(`GSC performance data (${rows.length} rows):
+`);
+  console.log(`  ${"DATE".padEnd(12)}${"QUERY".padEnd(30)}${"CLICKS".padEnd(8)}${"IMPR".padEnd(8)}${"CTR".padEnd(8)}${"POS".padEnd(6)}`);
+  console.log(`  ${"\u2500".repeat(12)}${"\u2500".repeat(30)}${"\u2500".repeat(8)}${"\u2500".repeat(8)}${"\u2500".repeat(8)}${"\u2500".repeat(6)}`);
+  for (const row of rows.slice(0, 50)) {
+    const query = row.query.length > 28 ? row.query.slice(0, 25) + "..." : row.query;
+    console.log(
+      `  ${row.date.padEnd(12)}${query.padEnd(30)}${String(row.clicks).padEnd(8)}${String(row.impressions).padEnd(8)}${(row.ctr * 100).toFixed(1).padStart(5)}%  ${row.position.toFixed(1).padStart(5)}`
+    );
+  }
+  if (rows.length > 50) {
+    console.log(`
+  ... and ${rows.length - 50} more rows (use --format json for full output)`);
+  }
+}
+async function googleInspect(project, url, format) {
+  const client = getClient11();
+  const result = await client.gscInspect(project, url);
+  if (format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`
+URL Inspection: ${result.url}
+`);
+  console.log(`  Indexing State:    ${result.indexingState ?? "unknown"}`);
+  console.log(`  Verdict:           ${result.verdict ?? "unknown"}`);
+  console.log(`  Coverage:          ${result.coverageState ?? "unknown"}`);
+  console.log(`  Page Fetch:        ${result.pageFetchState ?? "unknown"}`);
+  console.log(`  Robots.txt:        ${result.robotsTxtState ?? "unknown"}`);
+  console.log(`  Last Crawled:      ${result.crawlTime ?? "unknown"}`);
+  console.log(`  Mobile Friendly:   ${result.isMobileFriendly === true ? "Yes" : result.isMobileFriendly === false ? "No" : "unknown"}`);
+  console.log(`  Rich Results:      ${result.richResults?.length ? result.richResults.join(", ") : "none"}`);
+  console.log(`  Inspected At:      ${result.inspectedAt}`);
+}
+async function googleInspections(project, opts) {
+  const client = getClient11();
+  const params = {};
+  if (opts.url) params.url = opts.url;
+  const rows = await client.gscInspections(project, Object.keys(params).length > 0 ? params : void 0);
+  if (opts.format === "json") {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No URL inspections found.");
+    return;
+  }
+  console.log(`URL inspection history (${rows.length} records):
+`);
+  const urlWidth = Math.min(50, Math.max(10, ...rows.map((r) => r.url.length)));
+  console.log(`  ${"URL".padEnd(urlWidth)}  ${"INDEXING".padEnd(14)}${"VERDICT".padEnd(10)}${"INSPECTED".padEnd(22)}`);
+  console.log(`  ${"\u2500".repeat(urlWidth)}  ${"\u2500".repeat(14)}${"\u2500".repeat(10)}${"\u2500".repeat(22)}`);
+  for (const row of rows) {
+    const url = row.url.length > urlWidth ? row.url.slice(0, urlWidth - 3) + "..." : row.url;
+    console.log(
+      `  ${url.padEnd(urlWidth)}  ${(row.indexingState ?? "unknown").padEnd(14)}${(row.verdict ?? "-").padEnd(10)}${row.inspectedAt}`
+    );
+  }
+}
+async function googleDeindexed(project, format) {
+  const client = getClient11();
+  const rows = await client.gscDeindexed(project);
+  if (format === "json") {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No deindexed pages detected.");
+    return;
+  }
+  console.log(`Deindexed pages (${rows.length}):
+`);
+  for (const row of rows) {
+    console.log(`  ${row.url}`);
+    console.log(`    ${row.previousState} -> ${row.currentState}  (detected: ${row.transitionDate})`);
+    console.log();
+  }
+}
+
 // src/cli.ts
 import { createRequire } from "module";
 var USAGE = `
@@ -1330,8 +1638,19 @@ Usage:
   canonry notify remove <project> <id>  Remove notification
   canonry notify test <project> <id>  Send test webhook
   canonry notify events               List available notification event types
+  canonry google connect <project>     Connect Google Search Console (--type gsc|ga4)
+  canonry google disconnect <project> Disconnect Google integration
+  canonry google status <project>     Show Google connection status
+  canonry google properties <project> List available GSC properties
+  canonry google set-property <project> <url>  Set GSC property URL
+  canonry google sync <project>       Sync GSC data (--days 30, --full, --wait)
+  canonry google performance <project>  Show GSC search performance data
+  canonry google inspect <project> <url>  Inspect a URL via GSC
+  canonry google inspections <project>  Show URL inspection history (--url <url>)
+  canonry google deindexed <project>  Show pages that lost indexing
   canonry settings                    Show active provider and quota settings
   canonry settings provider <name>    Update a provider config
+  canonry settings google             Update Google OAuth credentials
   canonry telemetry status            Show telemetry status
   canonry telemetry enable            Enable anonymous telemetry
   canonry telemetry disable           Disable anonymous telemetry
@@ -1345,6 +1664,8 @@ Options:
   --local-url <url>    Local LLM base URL (or LOCAL_BASE_URL env var)
   --local-model <name> Local LLM model name (default: llama3)
   --local-key <key>    Local LLM API key (or LOCAL_API_KEY env var)
+  --google-client-id <id>      Google OAuth client ID (or GOOGLE_CLIENT_ID env var)
+  --google-client-secret <key> Google OAuth client secret (or GOOGLE_CLIENT_SECRET env var)
   --port <port>        Server port (default: 4100)
   --host <host>        Server bind address (default: 127.0.0.1)
   --domain <domain>    Canonical domain for project create/update
@@ -1367,6 +1688,8 @@ Options:
   --api-key <key>      Provider API key (settings provider)
   --base-url <url>     Provider base URL (settings provider)
   --model <name>       Provider model name (settings provider)
+  --client-id <id>     Google OAuth client ID (settings google)
+  --client-secret <key> Google OAuth client secret (settings google)
   --max-concurrent <n> Max concurrent requests per provider
   --max-per-minute <n> Max requests per minute per provider
   --max-per-day <n>    Max requests per day per provider
@@ -1394,7 +1717,7 @@ async function main() {
     showFirstRunNotice();
     getOrCreateAnonymousId();
   }
-  const SUBCOMMAND_COMMANDS = /* @__PURE__ */ new Set(["project", "keyword", "competitor", "schedule", "notify", "settings", "telemetry"]);
+  const SUBCOMMAND_COMMANDS = /* @__PURE__ */ new Set(["project", "keyword", "competitor", "schedule", "notify", "settings", "telemetry", "google"]);
   const resolvedCommand = SUBCOMMAND_COMMANDS.has(command) && args[1] && !args[1].startsWith("-") ? `${command}.${args[1]}` : command;
   if (command !== "telemetry") {
     trackEvent("cli.command", { command: resolvedCommand });
@@ -1411,7 +1734,9 @@ async function main() {
             "claude-key": { type: "string" },
             "local-url": { type: "string" },
             "local-model": { type: "string" },
-            "local-key": { type: "string" }
+            "local-key": { type: "string" },
+            "google-client-id": { type: "string" },
+            "google-client-secret": { type: "string" }
           },
           allowPositionals: false
         });
@@ -1422,7 +1747,9 @@ async function main() {
           claudeKey: initValues["claude-key"],
           localUrl: initValues["local-url"],
           localModel: initValues["local-model"],
-          localKey: initValues["local-key"]
+          localKey: initValues["local-key"],
+          googleClientId: initValues["google-client-id"],
+          googleClientSecret: initValues["google-client-secret"]
         });
         break;
       }
@@ -1913,6 +2240,23 @@ async function main() {
             model: values.model,
             quota: Object.keys(quota).length > 0 ? quota : void 0
           });
+        } else if (subcommand === "google") {
+          const { values } = parseArgs({
+            args: args.slice(2),
+            options: {
+              "client-id": { type: "string" },
+              "client-secret": { type: "string" }
+            },
+            allowPositionals: false
+          });
+          if (!values["client-id"] || !values["client-secret"]) {
+            console.error("Error: --client-id and --client-secret are both required");
+            process.exit(1);
+          }
+          setGoogleAuth({
+            clientId: values["client-id"],
+            clientSecret: values["client-secret"]
+          });
         } else {
           await showSettings(format);
         }
@@ -1922,6 +2266,165 @@ async function main() {
         telemetryCommand(args[1]);
         break;
       }
+      case "google": {
+        const subcommand = args[1];
+        switch (subcommand) {
+          case "connect": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            const { values: connectValues } = parseArgs({
+              args: args.slice(3),
+              options: {
+                type: { type: "string", default: "gsc" }
+              },
+              allowPositionals: false
+            });
+            await googleConnect(project, { type: connectValues.type ?? "gsc" });
+            break;
+          }
+          case "disconnect": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            const { values: disconnectValues } = parseArgs({
+              args: args.slice(3),
+              options: {
+                type: { type: "string", default: "gsc" }
+              },
+              allowPositionals: false
+            });
+            await googleDisconnect(project, { type: disconnectValues.type ?? "gsc" });
+            break;
+          }
+          case "status": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            await googleStatus(project, format);
+            break;
+          }
+          case "properties": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            await googleProperties(project, format);
+            break;
+          }
+          case "set-property": {
+            const project = args[2];
+            const propertyUrl = args[3];
+            if (!project || !propertyUrl) {
+              console.error("Error: project name and property URL are required");
+              process.exit(1);
+            }
+            await googleSetProperty(project, propertyUrl);
+            break;
+          }
+          case "sync": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            const { values: syncValues } = parseArgs({
+              args: args.slice(3),
+              options: {
+                type: { type: "string", default: "gsc" },
+                days: { type: "string" },
+                full: { type: "boolean", default: false },
+                wait: { type: "boolean", default: false },
+                format: { type: "string" }
+              },
+              allowPositionals: false
+            });
+            await googleSync(project, {
+              type: syncValues.type,
+              days: syncValues.days ? parseInt(syncValues.days, 10) : void 0,
+              full: syncValues.full,
+              wait: syncValues.wait,
+              format: syncValues.format === "json" ? "json" : format
+            });
+            break;
+          }
+          case "performance": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            const { values: perfValues } = parseArgs({
+              args: args.slice(3),
+              options: {
+                days: { type: "string" },
+                keyword: { type: "string" },
+                page: { type: "string" },
+                format: { type: "string" }
+              },
+              allowPositionals: false
+            });
+            await googlePerformance(project, {
+              days: perfValues.days ? parseInt(perfValues.days, 10) : void 0,
+              keyword: perfValues.keyword,
+              page: perfValues.page,
+              format: perfValues.format === "json" ? "json" : format
+            });
+            break;
+          }
+          case "inspect": {
+            const project = args[2];
+            const url = args[3];
+            if (!project || !url) {
+              console.error("Error: project name and URL are required");
+              process.exit(1);
+            }
+            await googleInspect(project, url, format);
+            break;
+          }
+          case "inspections": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            const { values: inspValues } = parseArgs({
+              args: args.slice(3),
+              options: {
+                url: { type: "string" },
+                format: { type: "string" }
+              },
+              allowPositionals: false
+            });
+            await googleInspections(project, {
+              url: inspValues.url,
+              format: inspValues.format === "json" ? "json" : format
+            });
+            break;
+          }
+          case "deindexed": {
+            const project = args[2];
+            if (!project) {
+              console.error("Error: project name is required");
+              process.exit(1);
+            }
+            await googleDeindexed(project, format);
+            break;
+          }
+          default:
+            console.error(`Unknown google subcommand: ${subcommand ?? "(none)"}`);
+            console.log("Available: connect, disconnect, status, properties, set-property, sync, performance, inspect, inspections, deindexed");
+            process.exit(1);
+        }
+        break;
+      }
       default:
         console.error(`Unknown command: ${command}`);
         console.log('Run "canonry --help" for usage.');