import { mkdir, writeFile } from "node:fs/promises";
import path from "node:path";
import { createInterface } from "node:readline/promises";
import { format } from "node:util";
import type { Command } from "commander";
import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
import { callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
import {
  buildGoogleMeetCalendarDayWindow,
  findGoogleMeetCalendarEvent,
  listGoogleMeetCalendarEvents,
  type GoogleMeetCalendarLookupResult,
} from "./calendar.js";
import type { GoogleMeetConfig, GoogleMeetModeInput, GoogleMeetTransport } from "./config.js";
import { hasCreateSpaceConfigInput, resolveCreateSpaceConfig } from "./create.js";
import {
  buildGoogleMeetPreflightReport,
  createGoogleMeetSpace,
  endGoogleMeetActiveConference,
  fetchGoogleMeetArtifacts,
  fetchGoogleMeetAttendance,
  fetchLatestGoogleMeetConferenceRecord,
  fetchGoogleMeetSpace,
  type GoogleMeetArtifactsResult,
  type GoogleMeetAttendanceResult,
  type GoogleMeetLatestConferenceRecordResult,
} from "./meet.js";
import {
  buildGoogleMeetAuthUrl,
  createGoogleMeetOAuthState,
  createGoogleMeetPkce,
  exchangeGoogleMeetAuthCode,
  resolveGoogleMeetAccessToken,
  waitForGoogleMeetAuthCode,
} from "./oauth.js";
import type { GoogleMeetRuntime } from "./runtime.js";

type JoinOptions = {
  transport?: GoogleMeetTransport;
  mode?: GoogleMeetModeInput;
  message?: string;
  timeoutMs?: string;
  dialInNumber?: string;
  pin?: string;
  dtmfSequence?: string;
};

type OAuthLoginOptions = {
  clientId?: string;
  clientSecret?: string;
  manual?: boolean;
  json?: boolean;
  timeoutSec?: string;
};

type ResolveSpaceOptions = {
  meeting?: string;
  today?: boolean;
  event?: string;
  calendar?: string;
  accessToken?: string;
  refreshToken?: string;
  clientId?: string;
  clientSecret?: string;
  expiresAt?: string;
  json?: boolean;
};

type MeetArtifactOptions = ResolveSpaceOptions & {
  conferenceRecord?: string;
  pageSize?: string;
  transcriptEntries?: boolean;
  allConferenceRecords?: boolean;
  includeDocBodies?: boolean;
  mergeDuplicates?: boolean;
  lateAfterMinutes?: string;
  earlyBeforeMinutes?: string;
  zip?: boolean;
  dryRun?: boolean;
  format?: "summary" | "markdown" | "csv";
  output?: string;
};

export type GoogleMeetExportRequest = {
  meeting?: string;
  conferenceRecord?: string;
  calendarEventId?: string;
  calendarEventSummary?: string;
  calendarId?: string;
  pageSize?: number;
  includeTranscriptEntries?: boolean;
  includeDocumentBodies?: boolean;
  allConferenceRecords?: boolean;
  mergeDuplicateParticipants?: boolean;
  lateAfterMinutes?: number;
  earlyBeforeMinutes?: number;
};

export type GoogleMeetExportWarning = {
  type:
    | "smart_notes"
    | "transcript_entries"
    | "transcript_document_body"
    | "smart_note_document_body";
  conferenceRecord: string;
  resource?: string;
  message: string;
};

export type GoogleMeetExportManifest = {
  generatedAt: string;
  request?: GoogleMeetExportRequest;
  tokenSource?: "cached-access-token" | "refresh-token";
  calendarEvent?: GoogleMeetCalendarLookupResult;
  inputs: {
    artifacts?: string;
    attendance?: string;
  };
  counts: {
    conferenceRecords: number;
    artifacts: number;
    attendanceRows: number;
    recordings: number;
    transcripts: number;
    transcriptEntries: number;
    smartNotes: number;
    warnings: number;
  };
  conferenceRecords: string[];
  files: string[];
  zipFile?: string;
  warnings: GoogleMeetExportWarning[];
};

type SetupOptions = {
  json?: boolean;
  mode?: GoogleMeetModeInput;
  transport?: GoogleMeetTransport;
};

type GoogleMeetGatewayMethod =
  | "googlemeet.create"
  | "googlemeet.join"
  | "googlemeet.leave"
  | "googlemeet.speak"
  | "googlemeet.status"
  | "googlemeet.testListen"
  | "googlemeet.testSpeech";

type GoogleMeetGatewayCallResult = { ok: true; payload: unknown } | { ok: false; error: unknown };

const GOOGLE_MEET_GATEWAY_DEFAULT_TIMEOUT_MS = 5000;

type DoctorOptions = {
  json?: boolean;
  oauth?: boolean;
  meeting?: string;
  createSpace?: boolean;
  accessToken?: string;
  refreshToken?: string;
  clientId?: string;
  clientSecret?: string;
  expiresAt?: string;
};

type JsonOptions = {
  json?: boolean;
};

type RecoverTabOptions = JsonOptions & {
  transport?: GoogleMeetTransport;
};

type CreateOptions = {
  accessToken?: string;
  refreshToken?: string;
  clientId?: string;
  clientSecret?: string;
  expiresAt?: string;
  accessType?: string;
  entryPointAccess?: string;
  join?: boolean;
  transport?: GoogleMeetTransport;
  mode?: GoogleMeetModeInput;
  message?: string;
  dialInNumber?: string;
  pin?: string;
  dtmfSequence?: string;
  json?: boolean;
};

function writeStdoutJson(value: unknown): void {
  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
}

function isGatewayUnavailableForLocalFallback(
  err: unknown,
  method: GoogleMeetGatewayMethod,
): boolean {
  const message = formatErrorMessage(err);
  return (
    message.includes("ECONNREFUSED") ||
    message.includes("ECONNRESET") ||
    message.includes("EHOSTUNREACH") ||
    message.includes("ENOTFOUND") ||
    message.includes("gateway not connected") ||
    message.includes(`unknown method: ${method}`)
  );
}

function writeStdoutLine(...values: unknown[]): void {
  process.stdout.write(`${format(...values)}\n`);
}

async function writeCliOutput(options: { output?: string }, text: string): Promise<void> {
  if (options.output?.trim()) {
    await writeFile(options.output, text.endsWith("\n") ? text : `${text}\n`, "utf8");
    writeStdoutLine("wrote: %s", options.output);
    return;
  }
  process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
}

async function promptInput(message: string): Promise<string> {
  const rl = createInterface({
    input: process.stdin,
    output: process.stderr,
  });
  try {
    return await rl.question(message);
  } finally {
    rl.close();
  }
}

function parseOptionalNumber(value: string | undefined): number | undefined {
  if (!value?.trim()) {
    return undefined;
  }
  const parsed = Number(value);
  if (!Number.isFinite(parsed)) {
    throw new Error(`Expected a numeric value, received ${value}`);
  }
  return parsed;
}

function writeSetupStatus(status: Awaited<ReturnType<GoogleMeetRuntime["setupStatus"]>>): void {
  writeStdoutLine("Google Meet setup: %s", status.ok ? "OK" : "needs attention");
  for (const check of status.checks) {
    writeStdoutLine("[%s] %s: %s", check.ok ? "ok" : "fail", check.id, check.message);
  }
}

function formatBoolean(value: boolean | undefined): string {
  return typeof value === "boolean" ? (value ? "yes" : "no") : "unknown";
}

function formatOptional(value: unknown): string {
  return typeof value === "string" && value.trim() ? value : "n/a";
}

function parsePositiveNumber(value: string | undefined, label: string): number | undefined {
  if (value === undefined) {
    return undefined;
  }
  const parsed = Number(value);
  if (!Number.isFinite(parsed) || parsed <= 0) {
    throw new Error(`${label} must be a positive number`);
  }
  return parsed;
}

async function callGoogleMeetGateway(params: {
  callGateway: typeof callGatewayFromCli;
  method: GoogleMeetGatewayMethod;
  payload?: Record<string, unknown>;
  timeoutMs?: number;
}): Promise<GoogleMeetGatewayCallResult> {
  try {
    const timeoutMs =
      typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)
        ? Math.max(1, Math.ceil(params.timeoutMs))
        : GOOGLE_MEET_GATEWAY_DEFAULT_TIMEOUT_MS;
    return {
      ok: true,
      payload: await params.callGateway(
        params.method,
        { json: true, timeout: String(timeoutMs) },
        params.payload,
        { progress: false },
      ),
    };
  } catch (err) {
    if (isGatewayUnavailableForLocalFallback(err, params.method)) {
      return { ok: false, error: err };
    }
    throw err;
  }
}

function resolveGoogleMeetGatewayOperationTimeoutMs(config: GoogleMeetConfig): number {
  return Math.max(
    60_000,
    config.chrome.joinTimeoutMs + 30_000,
    config.voiceCall.requestTimeoutMs + 10_000,
  );
}

function formatDuration(value: number | undefined): string {
  if (value === undefined) {
    return "n/a";
  }
  const totalSeconds = Math.round(value / 1000);
  const hours = Math.floor(totalSeconds / 3600);
  const minutes = Math.floor((totalSeconds % 3600) / 60);
  const seconds = totalSeconds % 60;
  return hours > 0
    ? `${hours}h ${minutes.toString().padStart(2, "0")}m`
    : `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
}

function writeDoctorStatus(status: Awaited<ReturnType<GoogleMeetRuntime["status"]>>): void {
  if (!status.found) {
    writeStdoutLine("Google Meet session: not found");
    return;
  }
  const sessions = status.session ? [status.session] : (status.sessions ?? []);
  if (sessions.length === 0) {
    writeStdoutLine("Google Meet sessions: none");
    return;
  }
  writeStdoutLine("Google Meet sessions: %d", sessions.length);
  for (const session of sessions) {
    const health = session.chrome?.health;
    writeStdoutLine("");
    writeStdoutLine("session: %s", session.id);
    writeStdoutLine("url: %s", session.url);
    writeStdoutLine("state: %s", session.state);
    writeStdoutLine("transport: %s", session.transport);
    writeStdoutLine("mode: %s", session.mode);
    if (session.twilio) {
      writeStdoutLine("twilio dial-in: %s", session.twilio.dialInNumber);
      writeStdoutLine("voice call id: %s", formatOptional(session.twilio.voiceCallId));
      writeStdoutLine("dtmf sent: %s", formatBoolean(session.twilio.dtmfSent));
      writeStdoutLine("intro sent: %s", formatBoolean(session.twilio.introSent));
    }
    if (!session.chrome) {
      continue;
    }
    writeStdoutLine("node: %s", session.chrome?.nodeId ?? "local/none");
    writeStdoutLine("audio bridge: %s", session.chrome?.audioBridge?.type ?? "none");
    const bridgeProvider =
      session.chrome?.audioBridge?.provider ??
      session.realtime.transcriptionProvider ??
      session.realtime.provider ??
      "n/a";
    writeStdoutLine(
      session.mode === "agent" ? "transcription provider: %s" : "provider: %s",
      bridgeProvider,
    );
    if (session.realtime.enabled) {
      writeStdoutLine("talk-back mode: %s", session.realtime.strategy ?? session.mode);
    }
    writeStdoutLine("in call: %s", formatBoolean(health?.inCall));
    writeStdoutLine("lobby waiting: %s", formatBoolean(health?.lobbyWaiting));
    writeStdoutLine("captioning: %s", formatBoolean(health?.captioning));
    writeStdoutLine("transcript lines: %s", health?.transcriptLines ?? 0);
    writeStdoutLine("last caption: %s", formatOptional(health?.lastCaptionAt));
    writeStdoutLine("manual action: %s", formatBoolean(health?.manualActionRequired));
    if (health?.manualActionRequired) {
      writeStdoutLine("manual reason: %s", formatOptional(health.manualActionReason));
      writeStdoutLine("manual message: %s", formatOptional(health.manualActionMessage));
    }
    writeStdoutLine("speech ready: %s", formatBoolean(health?.speechReady));
    if (health?.speechReady === false) {
      writeStdoutLine("speech blocked reason: %s", formatOptional(health.speechBlockedReason));
      writeStdoutLine("speech blocked message: %s", formatOptional(health.speechBlockedMessage));
    }
    writeStdoutLine("provider connected: %s", formatBoolean(health?.providerConnected));
    writeStdoutLine("realtime ready: %s", formatBoolean(health?.realtimeReady));
    writeStdoutLine("audio input active: %s", formatBoolean(health?.audioInputActive));
    writeStdoutLine("audio output active: %s", formatBoolean(health?.audioOutputActive));
    writeStdoutLine("meet output routed: %s", formatBoolean(health?.audioOutputRouted));
    if (health?.audioOutputDeviceLabel || health?.audioOutputRouteError) {
      writeStdoutLine("meet output device: %s", formatOptional(health.audioOutputDeviceLabel));
      writeStdoutLine("meet output route error: %s", formatOptional(health.audioOutputRouteError));
    }
    writeStdoutLine(
      "last input: %s (%s bytes)",
      formatOptional(health?.lastInputAt),
      health?.lastInputBytes ?? 0,
    );
    writeStdoutLine(
      "last output: %s (%s bytes)",
      formatOptional(health?.lastOutputAt),
      health?.lastOutputBytes ?? 0,
    );
    writeStdoutLine("bridge closed: %s", formatBoolean(health?.bridgeClosed));
    writeStdoutLine("browser url: %s", formatOptional(health?.browserUrl));
    if (health?.lastCaptionText) {
      const speaker = health.lastCaptionSpeaker ? `${health.lastCaptionSpeaker}: ` : "";
      writeStdoutLine("last caption text: %s%s", speaker, health.lastCaptionText);
    }
    writeStdoutLine("realtime transcript lines: %s", health?.realtimeTranscriptLines ?? 0);
    if (health?.lastRealtimeTranscriptText) {
      const role = health.lastRealtimeTranscriptRole
        ? `${health.lastRealtimeTranscriptRole}: `
        : "";
      writeStdoutLine("last realtime transcript: %s%s", role, health.lastRealtimeTranscriptText);
    }
    if (health?.lastRealtimeEventType) {
      const detail = health.lastRealtimeEventDetail ? ` ${health.lastRealtimeEventDetail}` : "";
      writeStdoutLine("last realtime event: %s%s", health.lastRealtimeEventType, detail);
    }
  }
}

type OAuthDoctorCheck = {
  id: string;
  ok: boolean;
  message: string;
};

type OAuthDoctorReport = {
  ok: boolean;
  configured: boolean;
  tokenSource?: "cached-access-token" | "refresh-token";
  expiresAt?: number;
  scope?: string;
  meetingUri?: string;
  createdSpace?: string;
  checks: OAuthDoctorCheck[];
};

function sanitizeOAuthErrorMessage(error: unknown): string {
  const message = error instanceof Error ? error.message : String(error);
  return message
    .replace(/(access_token["'=:\s]+)[^"',\s&]+/gi, "$1[redacted]")
    .replace(/(refresh_token["'=:\s]+)[^"',\s&]+/gi, "$1[redacted]")
    .replace(/(client_secret["'=:\s]+)[^"',\s&]+/gi, "$1[redacted]");
}

async function buildOAuthDoctorReport(
  config: GoogleMeetConfig,
  options: DoctorOptions,
): Promise<OAuthDoctorReport> {
  const clientId = options.clientId?.trim() || config.oauth.clientId;
  const clientSecret = options.clientSecret?.trim() || config.oauth.clientSecret;
  const refreshToken = options.refreshToken?.trim() || config.oauth.refreshToken;
  const accessToken = options.accessToken?.trim() || config.oauth.accessToken;
  const expiresAt = parseOptionalNumber(options.expiresAt) ?? config.oauth.expiresAt;
  const checks: OAuthDoctorCheck[] = [];

  const hasRefreshConfig = Boolean(clientId && refreshToken);
  const hasAccessConfig = Boolean(accessToken);
  if (!hasRefreshConfig && !hasAccessConfig) {
    checks.push({
      id: "oauth-config",
      ok: false,
      message:
        "Missing Google Meet OAuth credentials. Configure oauth.clientId and oauth.refreshToken, or pass --client-id and --refresh-token.",
    });
    return { ok: false, configured: false, checks };
  }

  checks.push({
    id: "oauth-config",
    ok: true,
    message: hasRefreshConfig
      ? "Google Meet OAuth refresh credentials are configured"
      : "Google Meet cached access token is configured",
  });

  let token: Awaited<ReturnType<typeof resolveGoogleMeetAccessToken>>;
  try {
    token = await resolveGoogleMeetAccessToken({
      clientId,
      clientSecret,
      refreshToken,
      accessToken,
      expiresAt,
    });
    checks.push({
      id: "oauth-token",
      ok: true,
      message: token.refreshed
        ? "Refresh token minted an access token"
        : "Cached access token is still valid",
    });
  } catch (error) {
    checks.push({
      id: "oauth-token",
      ok: false,
      message: sanitizeOAuthErrorMessage(error),
    });
    return { ok: false, configured: true, checks };
  }

  const report: OAuthDoctorReport = {
    ok: true,
    configured: true,
    tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
    expiresAt: token.expiresAt,
    checks,
  };

  const meeting = options.meeting?.trim();
  if (meeting) {
    try {
      const space = await fetchGoogleMeetSpace({ accessToken: token.accessToken, meeting });
      checks.push({
        id: "meet-spaces-get",
        ok: true,
        message: `Resolved ${space.name}`,
      });
      report.meetingUri = space.meetingUri;
    } catch (error) {
      checks.push({
        id: "meet-spaces-get",
        ok: false,
        message: sanitizeOAuthErrorMessage(error),
      });
    }
  }

  if (options.createSpace) {
    try {
      const created = await createGoogleMeetSpace({ accessToken: token.accessToken });
      checks.push({
        id: "meet-spaces-create",
        ok: true,
        message: `Created ${created.space.name}`,
      });
      report.createdSpace = created.space.name;
      report.meetingUri = created.meetingUri;
    } catch (error) {
      checks.push({
        id: "meet-spaces-create",
        ok: false,
        message: sanitizeOAuthErrorMessage(error),
      });
    }
  }

  report.ok = checks.every((check) => check.ok);
  return report;
}

function writeOAuthDoctorReport(report: OAuthDoctorReport): void {
  writeStdoutLine("Google Meet OAuth: %s", report.ok ? "OK" : "needs attention");
  writeStdoutLine("configured: %s", report.configured ? "yes" : "no");
  if (report.tokenSource) {
    writeStdoutLine("token source: %s", report.tokenSource);
  }
  if (report.meetingUri) {
    writeStdoutLine("meeting uri: %s", report.meetingUri);
  }
  for (const check of report.checks) {
    writeStdoutLine("[%s] %s: %s", check.ok ? "ok" : "fail", check.id, check.message);
  }
}

function writeRecoverCurrentTabResult(
  result: Awaited<ReturnType<GoogleMeetRuntime["recoverCurrentTab"]>>,
): void {
  writeStdoutLine("Google Meet current tab: %s", result.found ? "found" : "not found");
  writeStdoutLine("transport: %s", result.transport);
  writeStdoutLine("node: %s", result.nodeId ?? "local/none");
  if (result.targetId) {
    writeStdoutLine("target: %s", result.targetId);
  }
  if (result.tab?.url) {
    writeStdoutLine("tab url: %s", result.tab.url);
  }
  writeStdoutLine("message: %s", result.message);
  if (result.browser) {
    writeDoctorStatus({
      found: true,
      session: {
        id: "current-tab",
        url: result.browser.browserUrl ?? result.tab?.url ?? "unknown",
        transport: result.transport,
        mode: "transcribe",
        state: "active",
        createdAt: "",
        updatedAt: "",
        participantIdentity:
          result.transport === "chrome-node"
            ? "signed-in Google Chrome profile on a paired node"
            : "signed-in Google Chrome profile",
        realtime: { enabled: false, toolPolicy: "safe-read-only" },
        chrome: {
          audioBackend: "blackhole-2ch",
          launched: true,
          nodeId: result.nodeId,
          health: result.browser,
        },
        notes: [],
      },
    });
  }
}

function resolveMeetingInput(config: GoogleMeetConfig, value?: string): string {
  const meeting = value?.trim() || config.defaults.meeting;
  if (!meeting) {
    throw new Error(
      "Meeting input is required. Pass a URL/meeting code or configure defaults.meeting.",
    );
  }
  return meeting;
}

function resolveOAuthTokenOptions(
  config: GoogleMeetConfig,
  options: ResolveSpaceOptions,
): {
  clientId?: string;
  clientSecret?: string;
  refreshToken?: string;
  accessToken?: string;
  expiresAt?: number;
} {
  return {
    clientId: options.clientId?.trim() || config.oauth.clientId,
    clientSecret: options.clientSecret?.trim() || config.oauth.clientSecret,
    refreshToken: options.refreshToken?.trim() || config.oauth.refreshToken,
    accessToken: options.accessToken?.trim() || config.oauth.accessToken,
    expiresAt: parseOptionalNumber(options.expiresAt) ?? config.oauth.expiresAt,
  };
}

function resolveTokenOptions(
  config: GoogleMeetConfig,
  options: ResolveSpaceOptions,
): {
  meeting: string;
  clientId?: string;
  clientSecret?: string;
  refreshToken?: string;
  accessToken?: string;
  expiresAt?: number;
} {
  return {
    meeting: resolveMeetingInput(config, options.meeting),
    ...resolveOAuthTokenOptions(config, options),
  };
}

function hasCalendarLookupOptions(options: ResolveSpaceOptions): boolean {
  return Boolean(options.today || options.event?.trim());
}

async function resolveCalendarMeetingInput(params: {
  accessToken: string;
  options: ResolveSpaceOptions;
}): Promise<{ meeting?: string; calendarEvent?: GoogleMeetCalendarLookupResult }> {
  if (!hasCalendarLookupOptions(params.options)) {
    return {};
  }
  const window = params.options.today ? buildGoogleMeetCalendarDayWindow() : {};
  const calendarEvent = await findGoogleMeetCalendarEvent({
    accessToken: params.accessToken,
    calendarId: params.options.calendar,
    eventQuery: params.options.event,
    ...window,
  });
  return { meeting: calendarEvent.meetingUri, calendarEvent };
}

async function resolveMeetingForToken(params: {
  config: GoogleMeetConfig;
  options: ResolveSpaceOptions;
  accessToken: string;
  configuredMeeting?: string;
}): Promise<{ meeting: string; calendarEvent?: GoogleMeetCalendarLookupResult }> {
  const calendarMeeting = await resolveCalendarMeetingInput({
    accessToken: params.accessToken,
    options: params.options,
  });
  const meeting =
    calendarMeeting.meeting ?? params.configuredMeeting ?? params.config.defaults.meeting;
  if (!meeting) {
    throw new Error(
      "Meeting input is required. Pass --meeting, --today, --event, or configure defaults.meeting.",
    );
  }
  return calendarMeeting.calendarEvent
    ? { meeting, calendarEvent: calendarMeeting.calendarEvent }
    : { meeting };
}

function resolveCreateTokenOptions(
  config: GoogleMeetConfig,
  options: CreateOptions,
): {
  clientId?: string;
  clientSecret?: string;
  refreshToken?: string;
  accessToken?: string;
  expiresAt?: number;
} {
  return {
    clientId: options.clientId?.trim() || config.oauth.clientId,
    clientSecret: options.clientSecret?.trim() || config.oauth.clientSecret,
    refreshToken: options.refreshToken?.trim() || config.oauth.refreshToken,
    accessToken: options.accessToken?.trim() || config.oauth.accessToken,
    expiresAt: parseOptionalNumber(options.expiresAt) ?? config.oauth.expiresAt,
  };
}

function resolveArtifactTokenOptions(
  config: GoogleMeetConfig,
  options: MeetArtifactOptions,
): {
  meeting?: string;
  conferenceRecord?: string;
  clientId?: string;
  clientSecret?: string;
  refreshToken?: string;
  accessToken?: string;
  expiresAt?: number;
  pageSize?: number;
  includeTranscriptEntries?: boolean;
  allConferenceRecords?: boolean;
  includeDocumentBodies?: boolean;
  mergeDuplicateParticipants?: boolean;
  lateAfterMinutes?: number;
  earlyBeforeMinutes?: number;
} {
  const meeting = options.meeting?.trim() || config.defaults.meeting;
  const conferenceRecord = options.conferenceRecord?.trim();
  if (!meeting && !conferenceRecord && !hasCalendarLookupOptions(options)) {
    throw new Error(
      "Meeting input or conference record is required. Pass --meeting, --today, --event, --conference-record, or configure defaults.meeting.",
    );
  }
  return {
    meeting,
    conferenceRecord,
    clientId: options.clientId?.trim() || config.oauth.clientId,
    clientSecret: options.clientSecret?.trim() || config.oauth.clientSecret,
    refreshToken: options.refreshToken?.trim() || config.oauth.refreshToken,
    accessToken: options.accessToken?.trim() || config.oauth.accessToken,
    expiresAt: parseOptionalNumber(options.expiresAt) ?? config.oauth.expiresAt,
    pageSize: parseOptionalNumber(options.pageSize),
    includeTranscriptEntries: options.transcriptEntries !== false,
    allConferenceRecords: Boolean(options.allConferenceRecords),
    includeDocumentBodies: Boolean(options.includeDocBodies),
    mergeDuplicateParticipants: options.mergeDuplicates !== false,
    lateAfterMinutes: parseOptionalNumber(options.lateAfterMinutes),
    earlyBeforeMinutes: parseOptionalNumber(options.earlyBeforeMinutes),
  };
}

function hasCreateOAuth(config: GoogleMeetConfig, options: CreateOptions): boolean {
  return Boolean(
    options.accessToken?.trim() ||
    options.refreshToken?.trim() ||
    config.oauth.accessToken ||
    config.oauth.refreshToken,
  );
}

function writeArtifactsSummary(result: GoogleMeetArtifactsResult): void {
  if (result.input) {
    writeStdoutLine("input: %s", result.input);
  }
  if (result.space) {
    writeStdoutLine("space: %s", result.space.name);
  }
  writeStdoutLine("conference records: %d", result.conferenceRecords.length);
  for (const entry of result.artifacts) {
    writeStdoutLine("");
    writeStdoutLine("record: %s", entry.conferenceRecord.name);
    writeStdoutLine("started: %s", formatOptional(entry.conferenceRecord.startTime));
    writeStdoutLine("ended: %s", formatOptional(entry.conferenceRecord.endTime));
    writeStdoutLine("participants: %d", entry.participants.length);
    writeStdoutLine("recordings: %d", entry.recordings.length);
    writeStdoutLine("transcripts: %d", entry.transcripts.length);
    writeStdoutLine(
      "transcript entries: %d",
      entry.transcriptEntries.reduce((count, transcript) => count + transcript.entries.length, 0),
    );
    writeStdoutLine("smart notes: %d", entry.smartNotes.length);
    if (entry.smartNotesError) {
      writeStdoutLine("smart notes warning: %s", entry.smartNotesError);
    }
    for (const recording of entry.recordings) {
      writeStdoutLine("- recording: %s", recording.name);
    }
    for (const transcript of entry.transcripts) {
      writeStdoutLine("- transcript: %s", transcript.name);
      if (transcript.documentTextError) {
        writeStdoutLine("- transcript document body warning: %s", transcript.documentTextError);
      }
    }
    for (const transcriptEntries of entry.transcriptEntries) {
      if (transcriptEntries.entriesError) {
        writeStdoutLine(
          "- transcript entries warning: %s: %s",
          transcriptEntries.transcript,
          transcriptEntries.entriesError,
        );
      }
    }
    for (const smartNote of entry.smartNotes) {
      writeStdoutLine("- smart note: %s", smartNote.name);
      if (smartNote.documentTextError) {
        writeStdoutLine("- smart note document body warning: %s", smartNote.documentTextError);
      }
    }
  }
}

function writeAttendanceSummary(result: GoogleMeetAttendanceResult): void {
  if (result.input) {
    writeStdoutLine("input: %s", result.input);
  }
  if (result.space) {
    writeStdoutLine("space: %s", result.space.name);
  }
  writeStdoutLine("conference records: %d", result.conferenceRecords.length);
  writeStdoutLine("attendance rows: %d", result.attendance.length);
  for (const row of result.attendance) {
    const identity = row.displayName || row.user || row.participant;
    writeStdoutLine("");
    writeStdoutLine("participant: %s", identity);
    writeStdoutLine("record: %s", row.conferenceRecord);
    writeStdoutLine("resource: %s", row.participant);
    writeStdoutLine("participants merged: %d", row.participants?.length ?? 1);
    writeStdoutLine("first joined: %s", formatOptional(row.firstJoinTime ?? row.earliestStartTime));
    writeStdoutLine("last left: %s", formatOptional(row.lastLeaveTime ?? row.latestEndTime));
    writeStdoutLine("duration: %s", formatDuration(row.durationMs));
    writeStdoutLine("late: %s", row.late ? formatDuration(row.lateByMs) : "no");
    writeStdoutLine("early leave: %s", row.earlyLeave ? formatDuration(row.earlyLeaveByMs) : "no");
    writeStdoutLine("sessions: %d", row.sessions.length);
    for (const session of row.sessions) {
      writeStdoutLine(
        "- %s: %s -> %s",
        session.name,
        formatOptional(session.startTime),
        formatOptional(session.endTime),
      );
    }
  }
}

function writeLatestConferenceRecordSummary(result: GoogleMeetLatestConferenceRecordResult): void {
  writeStdoutLine("input: %s", result.input);
  writeStdoutLine("space: %s", result.space.name);
  if (!result.conferenceRecord) {
    writeStdoutLine("conference record: none");
    return;
  }
  writeStdoutLine("conference record: %s", result.conferenceRecord.name);
  writeStdoutLine("started: %s", formatOptional(result.conferenceRecord.startTime));
  writeStdoutLine("ended: %s", formatOptional(result.conferenceRecord.endTime));
}

function writeCalendarEventsSummary(
  result: Awaited<ReturnType<typeof listGoogleMeetCalendarEvents>>,
): void {
  writeStdoutLine("calendar: %s", result.calendarId);
  writeStdoutLine("meet events: %d", result.events.length);
  for (const entry of result.events) {
    writeStdoutLine("");
    writeStdoutLine("%s%s", entry.selected ? "* " : "- ", entry.event.summary ?? "untitled");
    writeStdoutLine("meeting uri: %s", entry.meetingUri);
    writeStdoutLine(
      "starts: %s",
      formatOptional(entry.event.start?.dateTime ?? entry.event.start?.date),
    );
    writeStdoutLine("ends: %s", formatOptional(entry.event.end?.dateTime ?? entry.event.end?.date));
  }
}

function pushMarkdownLine(lines: string[], text = ""): void {
  lines.push(text);
}

function formatMarkdownOptional(value: unknown): string {
  return typeof value === "string" && value.trim() ? value : "n/a";
}

function formatMarkdownIdentity(row: GoogleMeetAttendanceResult["attendance"][number]): string {
  return row.displayName || row.user || row.participant;
}

function participantDisplayName(
  entry: GoogleMeetArtifactsResult["artifacts"][number],
  name: string,
): string {
  const participant = entry.participants.find((candidate) => candidate.name === name);
  if (!participant) {
    return name;
  }
  return (
    participant.signedinUser?.displayName ??
    participant.anonymousUser?.displayName ??
    participant.phoneUser?.displayName ??
    participant.signedinUser?.user ??
    name
  );
}

function renderArtifactsMarkdown(result: GoogleMeetArtifactsResult): string {
  const lines: string[] = ["# Google Meet Artifacts"];
  if (result.input) {
    pushMarkdownLine(lines, `Input: ${result.input}`);
  }
  if (result.space) {
    pushMarkdownLine(lines, `Space: ${result.space.name}`);
  }
  pushMarkdownLine(lines);
  pushMarkdownLine(lines, `Conference records: ${result.conferenceRecords.length}`);
  for (const entry of result.artifacts) {
    pushMarkdownLine(lines);
    pushMarkdownLine(lines, `## ${entry.conferenceRecord.name}`);
    pushMarkdownLine(lines, `Started: ${formatMarkdownOptional(entry.conferenceRecord.startTime)}`);
    pushMarkdownLine(lines, `Ended: ${formatMarkdownOptional(entry.conferenceRecord.endTime)}`);
    pushMarkdownLine(lines);
    pushMarkdownLine(lines, `Participants: ${entry.participants.length}`);
    pushMarkdownLine(lines, `Recordings: ${entry.recordings.length}`);
    pushMarkdownLine(lines, `Transcripts: ${entry.transcripts.length}`);
    pushMarkdownLine(
      lines,
      `Transcript entries: ${entry.transcriptEntries.reduce(
        (count, transcript) => count + transcript.entries.length,
        0,
      )}`,
    );
    pushMarkdownLine(lines, `Smart notes: ${entry.smartNotes.length}`);
    const warnings = collectGoogleMeetArtifactWarnings({
      conferenceRecords: [entry.conferenceRecord],
      artifacts: [entry],
    });
    if (warnings.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Warnings");
      for (const warning of warnings) {
        const resource = warning.resource ? `${warning.resource}: ` : "";
        pushMarkdownLine(lines, `- ${resource}${warning.message}`);
      }
    }
    if (entry.recordings.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Recordings");
      for (const recording of entry.recordings) {
        pushMarkdownLine(lines, `- ${recording.name}`);
      }
    }
    if (entry.transcripts.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Transcripts");
      for (const transcript of entry.transcripts) {
        pushMarkdownLine(lines, `- ${transcript.name}`);
        if (transcript.documentTextError) {
          pushMarkdownLine(lines, `  - Document body warning: ${transcript.documentTextError}`);
        } else if (transcript.documentText) {
          pushMarkdownLine(lines, `  - Document body: ${transcript.documentText.length} chars`);
        }
      }
    }
    for (const transcriptEntries of entry.transcriptEntries) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, `### Transcript Entries: ${transcriptEntries.transcript}`);
      if (transcriptEntries.entriesError) {
        pushMarkdownLine(lines, `Warning: ${transcriptEntries.entriesError}`);
        continue;
      }
      if (transcriptEntries.entries.length === 0) {
        pushMarkdownLine(lines, "_No transcript entries._");
        continue;
      }
      for (const transcriptEntry of transcriptEntries.entries) {
        const times =
          transcriptEntry.startTime || transcriptEntry.endTime
            ? ` (${formatMarkdownOptional(transcriptEntry.startTime)} -> ${formatMarkdownOptional(
                transcriptEntry.endTime,
              )})`
            : "";
        const speaker = transcriptEntry.participant
          ? `${participantDisplayName(entry, transcriptEntry.participant)}: `
          : "";
        pushMarkdownLine(lines, `- ${speaker}${transcriptEntry.text ?? ""}${times}`);
      }
    }
    if (entry.smartNotes.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Smart Notes");
      for (const smartNote of entry.smartNotes) {
        pushMarkdownLine(lines, `- ${smartNote.name}`);
        if (smartNote.documentTextError) {
          pushMarkdownLine(lines, `  - Document body warning: ${smartNote.documentTextError}`);
        } else if (smartNote.documentText) {
          pushMarkdownLine(lines, `  - Document body: ${smartNote.documentText.length} chars`);
        }
      }
    }
  }
  return `${lines.join("\n")}\n`;
}

function renderAttendanceMarkdown(result: GoogleMeetAttendanceResult): string {
  const lines: string[] = ["# Google Meet Attendance"];
  if (result.input) {
    pushMarkdownLine(lines, `Input: ${result.input}`);
  }
  if (result.space) {
    pushMarkdownLine(lines, `Space: ${result.space.name}`);
  }
  pushMarkdownLine(lines);
  pushMarkdownLine(lines, `Conference records: ${result.conferenceRecords.length}`);
  pushMarkdownLine(lines, `Attendance rows: ${result.attendance.length}`);
  for (const row of result.attendance) {
    pushMarkdownLine(lines);
    pushMarkdownLine(lines, `## ${formatMarkdownIdentity(row)}`);
    pushMarkdownLine(lines, `Record: ${row.conferenceRecord}`);
    pushMarkdownLine(lines, `Resource: ${row.participant}`);
    pushMarkdownLine(lines, `Participants merged: ${row.participants?.length ?? 1}`);
    pushMarkdownLine(
      lines,
      `First joined: ${formatMarkdownOptional(row.firstJoinTime ?? row.earliestStartTime)}`,
    );
    pushMarkdownLine(
      lines,
      `Last left: ${formatMarkdownOptional(row.lastLeaveTime ?? row.latestEndTime)}`,
    );
    pushMarkdownLine(lines, `Duration: ${formatDuration(row.durationMs)}`);
    pushMarkdownLine(lines, `Late: ${row.late ? formatDuration(row.lateByMs) : "no"}`);
    pushMarkdownLine(
      lines,
      `Early leave: ${row.earlyLeave ? formatDuration(row.earlyLeaveByMs) : "no"}`,
    );
    pushMarkdownLine(lines, `Sessions: ${row.sessions.length}`);
    for (const session of row.sessions) {
      pushMarkdownLine(
        lines,
        `- ${session.name}: ${formatMarkdownOptional(session.startTime)} -> ${formatMarkdownOptional(
          session.endTime,
        )}`,
      );
    }
  }
  return `${lines.join("\n")}\n`;
}

function csvCell(value: unknown): string {
  const text =
    value === undefined || value === null
      ? ""
      : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
        ? String(value)
        : JSON.stringify(value);
  return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
}

function renderAttendanceCsv(result: GoogleMeetAttendanceResult): string {
  const rows: unknown[][] = [
    [
      "conferenceRecord",
      "displayName",
      "user",
      "participants",
      "firstJoined",
      "lastLeft",
      "durationMs",
      "sessions",
      "late",
      "lateByMs",
      "earlyLeave",
      "earlyLeaveByMs",
    ],
  ];
  for (const row of result.attendance) {
    rows.push([
      row.conferenceRecord,
      row.displayName ?? "",
      row.user ?? "",
      (row.participants ?? [row.participant]).join(";"),
      row.firstJoinTime ?? row.earliestStartTime ?? "",
      row.lastLeaveTime ?? row.latestEndTime ?? "",
      row.durationMs ?? "",
      row.sessions.length,
      row.late ?? "",
      row.lateByMs ?? "",
      row.earlyLeave ?? "",
      row.earlyLeaveByMs ?? "",
    ]);
  }
  return `${rows.map((row) => row.map(csvCell).join(",")).join("\n")}\n`;
}

function renderTranscriptMarkdown(result: GoogleMeetArtifactsResult): string {
  const lines: string[] = ["# Google Meet Transcript"];
  if (result.input) {
    pushMarkdownLine(lines, `Input: ${result.input}`);
  }
  for (const entry of result.artifacts) {
    pushMarkdownLine(lines);
    pushMarkdownLine(lines, `## ${entry.conferenceRecord.name}`);
    if (entry.transcriptEntries.length === 0) {
      pushMarkdownLine(lines, "_No transcript entries._");
      continue;
    }
    for (const transcriptEntries of entry.transcriptEntries) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, `### ${transcriptEntries.transcript}`);
      if (transcriptEntries.entriesError) {
        pushMarkdownLine(lines, `Warning: ${transcriptEntries.entriesError}`);
        continue;
      }
      for (const transcriptEntry of transcriptEntries.entries) {
        const speaker = transcriptEntry.participant
          ? participantDisplayName(entry, transcriptEntry.participant)
          : "unknown";
        const time = transcriptEntry.startTime ? ` [${transcriptEntry.startTime}]` : "";
        pushMarkdownLine(lines, `- ${speaker}${time}: ${transcriptEntry.text ?? ""}`);
      }
    }
    const docsTranscripts = entry.transcripts.filter((transcript) => transcript.documentText);
    if (docsTranscripts.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Transcript Document Bodies");
      for (const transcript of docsTranscripts) {
        pushMarkdownLine(lines);
        pushMarkdownLine(lines, `#### ${transcript.name}`);
        pushMarkdownLine(lines, transcript.documentText?.trim() || "_Empty document body._");
      }
    }
    const smartNotes = entry.smartNotes.filter((smartNote) => smartNote.documentText);
    if (smartNotes.length > 0) {
      pushMarkdownLine(lines);
      pushMarkdownLine(lines, "### Smart Note Document Bodies");
      for (const smartNote of smartNotes) {
        pushMarkdownLine(lines);
        pushMarkdownLine(lines, `#### ${smartNote.name}`);
        pushMarkdownLine(lines, smartNote.documentText?.trim() || "_Empty document body._");
      }
    }
  }
  return `${lines.join("\n")}\n`;
}

function collectGoogleMeetArtifactWarnings(
  result: GoogleMeetArtifactsResult,
): GoogleMeetExportWarning[] {
  const warnings: GoogleMeetExportWarning[] = [];
  for (const entry of result.artifacts) {
    const conferenceRecord = entry.conferenceRecord.name;
    if (entry.smartNotesError) {
      warnings.push({
        type: "smart_notes",
        conferenceRecord,
        message: entry.smartNotesError,
      });
    }
    for (const transcriptEntries of entry.transcriptEntries) {
      if (transcriptEntries.entriesError) {
        warnings.push({
          type: "transcript_entries",
          conferenceRecord,
          resource: transcriptEntries.transcript,
          message: transcriptEntries.entriesError,
        });
      }
    }
    for (const transcript of entry.transcripts) {
      if (transcript.documentTextError) {
        warnings.push({
          type: "transcript_document_body",
          conferenceRecord,
          resource: transcript.name,
          message: transcript.documentTextError,
        });
      }
    }
    for (const smartNote of entry.smartNotes) {
      if (smartNote.documentTextError) {
        warnings.push({
          type: "smart_note_document_body",
          conferenceRecord,
          resource: smartNote.name,
          message: smartNote.documentTextError,
        });
      }
    }
  }
  return warnings;
}

export function buildGoogleMeetExportManifest(params: {
  artifacts: GoogleMeetArtifactsResult;
  attendance: GoogleMeetAttendanceResult;
  files: string[];
  request?: GoogleMeetExportRequest;
  tokenSource?: "cached-access-token" | "refresh-token";
  calendarEvent?: GoogleMeetCalendarLookupResult;
  zipFile?: string;
}): GoogleMeetExportManifest {
  const transcriptEntryCount = params.artifacts.artifacts.reduce(
    (count, entry) =>
      count +
      entry.transcriptEntries.reduce(
        (entryCount, transcript) => entryCount + transcript.entries.length,
        0,
      ),
    0,
  );
  const warnings = collectGoogleMeetArtifactWarnings(params.artifacts);
  return {
    generatedAt: new Date().toISOString(),
    ...(params.request ? { request: params.request } : {}),
    ...(params.tokenSource ? { tokenSource: params.tokenSource } : {}),
    ...(params.calendarEvent ? { calendarEvent: params.calendarEvent } : {}),
    inputs: {
      ...(params.artifacts.input ? { artifacts: params.artifacts.input } : {}),
      ...(params.attendance.input ? { attendance: params.attendance.input } : {}),
    },
    counts: {
      conferenceRecords: params.artifacts.conferenceRecords.length,
      artifacts: params.artifacts.artifacts.length,
      attendanceRows: params.attendance.attendance.length,
      recordings: params.artifacts.artifacts.reduce(
        (count, entry) => count + entry.recordings.length,
        0,
      ),
      transcripts: params.artifacts.artifacts.reduce(
        (count, entry) => count + entry.transcripts.length,
        0,
      ),
      transcriptEntries: transcriptEntryCount,
      smartNotes: params.artifacts.artifacts.reduce(
        (count, entry) => count + entry.smartNotes.length,
        0,
      ),
      warnings: warnings.length,
    },
    conferenceRecords: params.artifacts.conferenceRecords.map((record) => record.name),
    files: params.files,
    ...(params.zipFile ? { zipFile: params.zipFile } : {}),
    warnings,
  };
}

export function googleMeetExportFileNames(): string[] {
  return [
    "summary.md",
    "attendance.csv",
    "transcript.md",
    "artifacts.json",
    "attendance.json",
    "manifest.json",
  ];
}

function defaultExportDirectory(): string {
  return `google-meet-export-${new Date().toISOString().replace(/[:.]/g, "-")}`;
}

const CRC32_TABLE = new Uint32Array(
  Array.from({ length: 256 }, (_, index) => {
    let value = index;
    for (let bit = 0; bit < 8; bit += 1) {
      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
    }
    return value >>> 0;
  }),
);

function crc32(buffer: Buffer): number {
  let value = 0xffffffff;
  for (const byte of buffer) {
    value = CRC32_TABLE[(value ^ byte) & 0xff] ^ (value >>> 8);
  }
  return (value ^ 0xffffffff) >>> 0;
}

function dosDateTime(date = new Date()): { date: number; time: number } {
  return {
    time: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
    date: ((date.getFullYear() - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
  };
}

function buildZipArchive(files: Array<{ name: string; content: string }>): Buffer {
  const localParts: Buffer[] = [];
  const centralParts: Buffer[] = [];
  let offset = 0;
  const stamp = dosDateTime();
  for (const file of files) {
    const name = Buffer.from(file.name, "utf8");
    const content = Buffer.from(file.content, "utf8");
    const checksum = crc32(content);
    const local = Buffer.alloc(30);
    local.writeUInt32LE(0x04034b50, 0);
    local.writeUInt16LE(20, 4);
    local.writeUInt16LE(0, 6);
    local.writeUInt16LE(0, 8);
    local.writeUInt16LE(stamp.time, 10);
    local.writeUInt16LE(stamp.date, 12);
    local.writeUInt32LE(checksum, 14);
    local.writeUInt32LE(content.length, 18);
    local.writeUInt32LE(content.length, 22);
    local.writeUInt16LE(name.length, 26);
    local.writeUInt16LE(0, 28);
    localParts.push(local, name, content);

    const central = Buffer.alloc(46);
    central.writeUInt32LE(0x02014b50, 0);
    central.writeUInt16LE(20, 4);
    central.writeUInt16LE(20, 6);
    central.writeUInt16LE(0, 8);
    central.writeUInt16LE(0, 10);
    central.writeUInt16LE(stamp.time, 12);
    central.writeUInt16LE(stamp.date, 14);
    central.writeUInt32LE(checksum, 16);
    central.writeUInt32LE(content.length, 20);
    central.writeUInt32LE(content.length, 24);
    central.writeUInt16LE(name.length, 28);
    central.writeUInt16LE(0, 30);
    central.writeUInt16LE(0, 32);
    central.writeUInt16LE(0, 34);
    central.writeUInt16LE(0, 36);
    central.writeUInt32LE(0, 38);
    central.writeUInt32LE(offset, 42);
    centralParts.push(central, name);
    offset += local.length + name.length + content.length;
  }
  const centralDirectory = Buffer.concat(centralParts);
  const end = Buffer.alloc(22);
  end.writeUInt32LE(0x06054b50, 0);
  end.writeUInt16LE(0, 4);
  end.writeUInt16LE(0, 6);
  end.writeUInt16LE(files.length, 8);
  end.writeUInt16LE(files.length, 10);
  end.writeUInt32LE(centralDirectory.length, 12);
  end.writeUInt32LE(offset, 16);
  end.writeUInt16LE(0, 20);
  return Buffer.concat([...localParts, centralDirectory, end]);
}

export async function writeMeetExportBundle(params: {
  outputDir?: string;
  artifacts: GoogleMeetArtifactsResult;
  attendance: GoogleMeetAttendanceResult;
  zip?: boolean;
  request?: GoogleMeetExportRequest;
  tokenSource?: "cached-access-token" | "refresh-token";
  calendarEvent?: GoogleMeetCalendarLookupResult;
}): Promise<{ outputDir: string; files: string[]; zipFile?: string }> {
  const outputDir = params.outputDir?.trim() || defaultExportDirectory();
  await mkdir(outputDir, { recursive: true });
  const zipFile = params.zip ? `${outputDir.replace(/\/$/, "")}.zip` : undefined;
  const fileNames = googleMeetExportFileNames();
  const files = [
    {
      name: "summary.md",
      content: `${renderArtifactsMarkdown(params.artifacts)}\n${renderAttendanceMarkdown(params.attendance)}`,
    },
    { name: "attendance.csv", content: renderAttendanceCsv(params.attendance) },
    { name: "transcript.md", content: renderTranscriptMarkdown(params.artifacts) },
    { name: "artifacts.json", content: `${JSON.stringify(params.artifacts, null, 2)}\n` },
    { name: "attendance.json", content: `${JSON.stringify(params.attendance, null, 2)}\n` },
    {
      name: "manifest.json",
      content: `${JSON.stringify(
        buildGoogleMeetExportManifest({
          artifacts: params.artifacts,
          attendance: params.attendance,
          files: fileNames,
          ...(params.request ? { request: params.request } : {}),
          ...(params.tokenSource ? { tokenSource: params.tokenSource } : {}),
          ...(params.calendarEvent ? { calendarEvent: params.calendarEvent } : {}),
          ...(zipFile ? { zipFile } : {}),
        }),
        null,
        2,
      )}\n`,
    },
  ];
  for (const file of files) {
    await writeFile(path.join(outputDir, file.name), file.content, "utf8");
  }
  const result: { outputDir: string; files: string[]; zipFile?: string } = {
    outputDir,
    files: files.map((file) => path.join(outputDir, file.name)),
  };
  if (zipFile) {
    await writeFile(zipFile, buildZipArchive(files));
    result.zipFile = zipFile;
  }
  return result;
}

export function registerGoogleMeetCli(params: {
  program: Command;
  config: GoogleMeetConfig;
  ensureRuntime: () => Promise<GoogleMeetRuntime>;
  callGatewayFromCli?: typeof callGatewayFromCli;
}) {
  const callGateway = params.callGatewayFromCli ?? callGatewayFromCli;
  const operationTimeoutMs = resolveGoogleMeetGatewayOperationTimeoutMs(params.config);
  const root = params.program
    .command("googlemeet")
    .description("Google Meet participant utilities")
    .addHelpText("after", () => `\nDocs: https://docs.openclaw.ai/plugins/google-meet\n`);

  const auth = root.command("auth").description("Google Meet OAuth helpers");

  auth
    .command("login")
    .description("Run a PKCE OAuth flow and print refresh-token JSON to store in plugin config")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--manual", "Use copy/paste callback flow instead of localhost callback")
    .option("--json", "Print the token payload as JSON", false)
    .option("--timeout-sec <n>", "Local callback timeout in seconds", "300")
    .action(async (options: OAuthLoginOptions) => {
      const clientId = options.clientId?.trim() || params.config.oauth.clientId;
      const clientSecret = options.clientSecret?.trim() || params.config.oauth.clientSecret;
      if (!clientId) {
        throw new Error(
          "Missing Google Meet OAuth client id. Configure oauth.clientId or pass --client-id.",
        );
      }
      const { verifier, challenge } = createGoogleMeetPkce();
      const state = createGoogleMeetOAuthState();
      const authUrl = buildGoogleMeetAuthUrl({
        clientId,
        challenge,
        state,
      });
      const code = await waitForGoogleMeetAuthCode({
        state,
        manual: Boolean(options.manual),
        timeoutMs: (parseOptionalNumber(options.timeoutSec) ?? 300) * 1000,
        authUrl,
        promptInput,
        writeLine: (message) => writeStdoutLine("%s", message),
      });
      const tokens = await exchangeGoogleMeetAuthCode({
        clientId,
        clientSecret,
        code,
        verifier,
      });
      if (!tokens.refreshToken) {
        throw new Error(
          "Google OAuth did not return a refresh token. Re-run the flow with consent and offline access.",
        );
      }
      const payload = {
        oauth: {
          clientId,
          ...(clientSecret ? { clientSecret } : {}),
          refreshToken: tokens.refreshToken,
          accessToken: tokens.accessToken,
          expiresAt: tokens.expiresAt,
        },
        scope: tokens.scope,
        tokenType: tokens.tokenType,
      };
      if (!options.json) {
        writeStdoutLine("Paste this into plugins.entries.google-meet.config:");
      }
      writeStdoutJson(payload);
    });

  root
    .command("create")
    .description("Create a new Google Meet space and print its meeting URL")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option(
      "--access-type <type>",
      "Google Meet SpaceConfig accessType for API create: OPEN, TRUSTED, or RESTRICTED",
    )
    .option(
      "--entry-point-access <type>",
      "Google Meet SpaceConfig entryPointAccess for API create: ALL or CREATOR_APP_ONLY",
    )
    .option("--no-join", "Only create the meeting URL; do not join it")
    .option("--transport <transport>", "Join transport: chrome, chrome-node, or twilio")
    .option("--mode <mode>", "Join mode: agent, bidi, or transcribe")
    .option("--message <text>", "Realtime speech to trigger after join")
    .option("--dial-in-number <phone>", "Meet dial-in number for Twilio transport")
    .option("--pin <pin>", "Meet phone PIN; # is appended if omitted")
    .option("--dtmf-sequence <sequence>", "Explicit Twilio DTMF sequence")
    .option("--json", "Print JSON output", false)
    .action(async (options: CreateOptions) => {
      if (options.join !== false) {
        const delegated = await callGoogleMeetGateway({
          callGateway,
          method: "googlemeet.create",
          payload: { ...options },
          timeoutMs: operationTimeoutMs,
        });
        if (delegated.ok) {
          const payload = delegated.payload as {
            browser?: { nodeId?: string };
            joined?: boolean;
            join?: { session?: { id?: string } };
            meetingUri?: string;
            source?: string;
            space?: { name?: string; meetingCode?: string };
            tokenSource?: string;
          };
          if (options.json) {
            writeStdoutJson(payload);
            return;
          }
          writeStdoutLine("meeting uri: %s", payload.meetingUri);
          if (payload.space?.name) {
            writeStdoutLine("space: %s", payload.space.name);
          }
          if (payload.space?.meetingCode) {
            writeStdoutLine("meeting code: %s", payload.space.meetingCode);
          }
          if (payload.source) {
            writeStdoutLine("source: %s", payload.source);
          }
          if (payload.browser?.nodeId) {
            writeStdoutLine("node: %s", payload.browser.nodeId);
          }
          if (payload.tokenSource) {
            writeStdoutLine("token source: %s", payload.tokenSource);
          }
          if (payload.joined && payload.join?.session?.id) {
            writeStdoutLine("joined: %s", payload.join.session.id);
          } else {
            writeStdoutLine("joined: no (run `openclaw googlemeet join %s`)", payload.meetingUri);
          }
          return;
        }
      }
      if (!hasCreateOAuth(params.config, options)) {
        if (hasCreateSpaceConfigInput(options as Record<string, unknown>)) {
          throw new Error(
            "Google Meet access policy options require OAuth/API room creation. Configure Google Meet OAuth or remove --access-type/--entry-point-access.",
          );
        }
        const rt = await params.ensureRuntime();
        const result = await rt.createViaBrowser();
        const join =
          options.join !== false
            ? await rt.join({
                url: result.meetingUri,
                transport: options.transport,
                mode: options.mode,
                message: options.message,
                dialInNumber: options.dialInNumber,
                pin: options.pin,
                dtmfSequence: options.dtmfSequence,
              })
            : undefined;
        const payload = {
          source: result.source,
          meetingUri: result.meetingUri,
          joined: Boolean(join),
          ...(join ? { join } : {}),
          browser: {
            nodeId: result.nodeId,
            targetId: result.targetId,
            browserUrl: result.browserUrl,
            browserTitle: result.browserTitle,
          },
        };
        if (options.json) {
          writeStdoutJson(payload);
          return;
        }
        writeStdoutLine("meeting uri: %s", result.meetingUri);
        writeStdoutLine("source: browser");
        writeStdoutLine("node: %s", result.nodeId);
        if (join) {
          writeStdoutLine("joined: %s", join.session.id);
        } else {
          writeStdoutLine("joined: no (run `openclaw googlemeet join %s`)", result.meetingUri);
        }
        return;
      }
      const token = await resolveGoogleMeetAccessToken(
        resolveCreateTokenOptions(params.config, options),
      );
      const result = await createGoogleMeetSpace({
        accessToken: token.accessToken,
        config: resolveCreateSpaceConfig(options as Record<string, unknown>),
      });
      const join =
        options.join !== false
          ? await (
              await params.ensureRuntime()
            ).join({
              url: result.meetingUri,
              transport: options.transport,
              mode: options.mode,
              message: options.message,
              dialInNumber: options.dialInNumber,
              pin: options.pin,
              dtmfSequence: options.dtmfSequence,
            })
          : undefined;
      if (options.json) {
        writeStdoutJson({
          ...result,
          tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
          joined: Boolean(join),
          ...(join ? { join } : {}),
        });
        return;
      }
      writeStdoutLine("meeting uri: %s", result.meetingUri);
      writeStdoutLine("space: %s", result.space.name);
      if (result.space.meetingCode) {
        writeStdoutLine("meeting code: %s", result.space.meetingCode);
      }
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
      if (join) {
        writeStdoutLine("joined: %s", join.session.id);
      } else {
        writeStdoutLine("joined: no (run `openclaw googlemeet join %s`)", result.meetingUri);
      }
    });

  root
    .command("end-active-conference")
    .description("End the active conference for a Google Meet space")
    .argument("[meeting]", "Meet URL, meeting code, or spaces/{id}")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (meeting: string | undefined, options: ResolveSpaceOptions & JsonOptions) => {
      const token = await resolveGoogleMeetAccessToken(
        resolveOAuthTokenOptions(params.config, options),
      );
      const result = await endGoogleMeetActiveConference({
        accessToken: token.accessToken,
        meeting: resolveMeetingInput(params.config, meeting ?? options.meeting),
      });
      if (options.json) {
        writeStdoutJson({
          ...result,
          tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
        });
        return;
      }
      writeStdoutLine("space: %s", result.space);
      writeStdoutLine("ended: yes");
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("join")
    .argument("[url]", "Explicit https://meet.google.com/... URL")
    .option("--transport <transport>", "Transport: chrome, chrome-node, or twilio")
    .option("--mode <mode>", "Mode: agent, bidi, or transcribe")
    .option("--message <text>", "Realtime speech to trigger after join")
    .option("--dial-in-number <phone>", "Meet dial-in number for Twilio transport")
    .option("--pin <pin>", "Meet phone PIN; # is appended if omitted")
    .option("--dtmf-sequence <sequence>", "Explicit Twilio DTMF sequence")
    .action(async (url: string | undefined, options: JoinOptions) => {
      const payload = {
        url: resolveMeetingInput(params.config, url),
        transport: options.transport,
        mode: options.mode,
        message: options.message,
        dialInNumber: options.dialInNumber,
        pin: options.pin,
        dtmfSequence: options.dtmfSequence,
      };
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.join",
        payload,
        timeoutMs: operationTimeoutMs,
      });
      if (delegated.ok) {
        const result = delegated.payload as { session?: unknown };
        writeStdoutJson(result.session ?? delegated.payload);
        return;
      }
      const rt = await params.ensureRuntime();
      const result = await rt.join(payload);
      writeStdoutJson(result.session);
    });

  root
    .command("test-speech")
    .argument("[url]", "Explicit https://meet.google.com/... URL")
    .option("--transport <transport>", "Transport: chrome, chrome-node, or twilio")
    .option("--mode <mode>", "Mode: agent, bidi, or transcribe")
    .option(
      "--message <text>",
      "Realtime speech to trigger",
      "Say exactly: Google Meet speech test complete.",
    )
    .action(async (url: string | undefined, options: JoinOptions) => {
      const payload = {
        url: resolveMeetingInput(params.config, url),
        transport: options.transport,
        mode: options.mode,
        message: options.message,
      };
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.testSpeech",
        payload,
        timeoutMs: operationTimeoutMs,
      });
      if (delegated.ok) {
        writeStdoutJson(delegated.payload);
        return;
      }
      const rt = await params.ensureRuntime();
      writeStdoutJson(await rt.testSpeech(payload));
    });

  root
    .command("test-listen")
    .argument("[url]", "Explicit https://meet.google.com/... URL")
    .option("--transport <transport>", "Transport: chrome or chrome-node")
    .option("--timeout-ms <ms>", "How long to wait for fresh captions/transcript movement")
    .action(async (url: string | undefined, options: JoinOptions) => {
      const payload = {
        url: resolveMeetingInput(params.config, url),
        transport: options.transport,
        timeoutMs: parsePositiveNumber(options.timeoutMs, "timeout-ms"),
      };
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.testListen",
        payload,
        timeoutMs: operationTimeoutMs,
      });
      if (delegated.ok) {
        writeStdoutJson(delegated.payload);
        return;
      }
      const rt = await params.ensureRuntime();
      writeStdoutJson(await rt.testListen(payload));
    });

  root
    .command("resolve-space")
    .description("Resolve a Meet URL, meeting code, or spaces/{id} to its canonical space")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (options: ResolveSpaceOptions) => {
      const resolved = resolveTokenOptions(params.config, options);
      const token = await resolveGoogleMeetAccessToken(resolved);
      const space = await fetchGoogleMeetSpace({
        accessToken: token.accessToken,
        meeting: resolved.meeting,
      });
      if (options.json) {
        writeStdoutJson(space);
        return;
      }
      writeStdoutLine("input: %s", resolved.meeting);
      writeStdoutLine("space: %s", space.name);
      if (space.meetingCode) {
        writeStdoutLine("meeting code: %s", space.meetingCode);
      }
      if (space.meetingUri) {
        writeStdoutLine("meeting uri: %s", space.meetingUri);
      }
      writeStdoutLine("active conference: %s", space.activeConference ? "yes" : "no");
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("preflight")
    .description("Validate OAuth + meeting resolution prerequisites for Meet media work")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (options: ResolveSpaceOptions) => {
      const resolved = resolveTokenOptions(params.config, options);
      const token = await resolveGoogleMeetAccessToken(resolved);
      const space = await fetchGoogleMeetSpace({
        accessToken: token.accessToken,
        meeting: resolved.meeting,
      });
      const report = buildGoogleMeetPreflightReport({
        input: resolved.meeting,
        space,
        previewAcknowledged: params.config.preview.enrollmentAcknowledged,
        tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
      });
      if (options.json) {
        writeStdoutJson(report);
        return;
      }
      writeStdoutLine("input: %s", report.input);
      writeStdoutLine("resolved space: %s", report.resolvedSpaceName);
      if (report.meetingCode) {
        writeStdoutLine("meeting code: %s", report.meetingCode);
      }
      if (report.meetingUri) {
        writeStdoutLine("meeting uri: %s", report.meetingUri);
      }
      writeStdoutLine("active conference: %s", report.hasActiveConference ? "yes" : "no");
      writeStdoutLine("preview acknowledged: %s", report.previewAcknowledged ? "yes" : "no");
      writeStdoutLine("token source: %s", report.tokenSource);
      if (report.blockers.length === 0) {
        writeStdoutLine("blockers: none");
        return;
      }
      writeStdoutLine("blockers:");
      for (const blocker of report.blockers) {
        writeStdoutLine("- %s", blocker);
      }
    });

  root
    .command("latest")
    .description("Find the latest Meet conference record for a meeting")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--today", "Find a Meet link on today's calendar")
    .option("--event <query>", "Find a matching calendar event with a Meet link")
    .option("--calendar <id>", "Calendar id for --today or --event", "primary")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (options: ResolveSpaceOptions) => {
      const token = await resolveGoogleMeetAccessToken(
        resolveOAuthTokenOptions(params.config, options),
      );
      const resolved = await resolveMeetingForToken({
        config: params.config,
        options,
        accessToken: token.accessToken,
        configuredMeeting: options.meeting?.trim(),
      });
      const result = await fetchLatestGoogleMeetConferenceRecord({
        accessToken: token.accessToken,
        meeting: resolved.meeting,
      });
      if (options.json) {
        writeStdoutJson({
          ...result,
          ...(resolved.calendarEvent ? { calendarEvent: resolved.calendarEvent } : {}),
          tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
        });
        return;
      }
      if (resolved.calendarEvent) {
        writeStdoutLine("calendar event: %s", resolved.calendarEvent.event.summary ?? "untitled");
        writeStdoutLine("calendar meet: %s", resolved.calendarEvent.meetingUri);
      }
      writeLatestConferenceRecordSummary(result);
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("calendar-events")
    .description("Preview Calendar events with Google Meet links")
    .option("--today", "Find Meet links on today's calendar")
    .option("--event <query>", "Find matching calendar events with Meet links")
    .option("--calendar <id>", "Calendar id for lookup", "primary")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (options: ResolveSpaceOptions) => {
      const token = await resolveGoogleMeetAccessToken(
        resolveOAuthTokenOptions(params.config, options),
      );
      const window = options.today ? buildGoogleMeetCalendarDayWindow() : {};
      const result = await listGoogleMeetCalendarEvents({
        accessToken: token.accessToken,
        calendarId: options.calendar,
        eventQuery: options.event,
        ...window,
      });
      const payload = {
        ...result,
        tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
      };
      if (options.json) {
        writeStdoutJson(payload);
        return;
      }
      writeCalendarEventsSummary(result);
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("artifacts")
    .description("List Meet conference records and available participant/artifact metadata")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--conference-record <name>", "Conference record name or id")
    .option("--today", "Find a Meet link on today's calendar")
    .option("--event <query>", "Find a matching calendar event with a Meet link")
    .option("--calendar <id>", "Calendar id for --today or --event", "primary")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--page-size <n>", "Max resources per Meet API page")
    .option("--all-conference-records", "Fetch every conference record for --meeting")
    .option("--no-transcript-entries", "Skip structured transcript entry lookup")
    .option("--include-doc-bodies", "Export linked transcript and smart-note Google Docs text")
    .option("--format <format>", "Output format: summary or markdown", "summary")
    .option("--output <path>", "Write output to a file instead of stdout")
    .option("--json", "Print JSON output", false)
    .action(async (options: MeetArtifactOptions) => {
      const resolved = resolveArtifactTokenOptions(params.config, options);
      const token = await resolveGoogleMeetAccessToken(resolved);
      const meeting = resolved.conferenceRecord
        ? resolved.meeting
        : (
            await resolveMeetingForToken({
              config: params.config,
              options,
              accessToken: token.accessToken,
              configuredMeeting: resolved.meeting,
            })
          ).meeting;
      const result = await fetchGoogleMeetArtifacts({
        accessToken: token.accessToken,
        meeting,
        conferenceRecord: resolved.conferenceRecord,
        pageSize: resolved.pageSize,
        includeTranscriptEntries: resolved.includeTranscriptEntries,
        allConferenceRecords: resolved.allConferenceRecords,
        includeDocumentBodies: resolved.includeDocumentBodies,
      });
      if (options.json) {
        await writeCliOutput(
          options,
          JSON.stringify(
            {
              ...result,
              tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
            },
            null,
            2,
          ),
        );
        return;
      }
      if (options.format === "markdown") {
        await writeCliOutput(options, renderArtifactsMarkdown(result));
        return;
      }
      if (options.format && options.format !== "summary") {
        throw new Error("Unsupported format. Expected summary or markdown.");
      }
      writeArtifactsSummary(result);
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("attendance")
    .description("List Meet participants and participant sessions")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--conference-record <name>", "Conference record name or id")
    .option("--today", "Find a Meet link on today's calendar")
    .option("--event <query>", "Find a matching calendar event with a Meet link")
    .option("--calendar <id>", "Calendar id for --today or --event", "primary")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--page-size <n>", "Max resources per Meet API page")
    .option("--all-conference-records", "Fetch every conference record for --meeting")
    .option("--no-merge-duplicates", "Keep duplicate participant resources as separate rows")
    .option("--late-after-minutes <n>", "Mark participants late after this many minutes", "5")
    .option("--early-before-minutes <n>", "Mark early leavers before this many minutes", "5")
    .option("--format <format>", "Output format: summary, markdown, or csv", "summary")
    .option("--output <path>", "Write output to a file instead of stdout")
    .option("--json", "Print JSON output", false)
    .action(async (options: MeetArtifactOptions) => {
      const resolved = resolveArtifactTokenOptions(params.config, options);
      const token = await resolveGoogleMeetAccessToken(resolved);
      const meeting = resolved.conferenceRecord
        ? resolved.meeting
        : (
            await resolveMeetingForToken({
              config: params.config,
              options,
              accessToken: token.accessToken,
              configuredMeeting: resolved.meeting,
            })
          ).meeting;
      const result = await fetchGoogleMeetAttendance({
        accessToken: token.accessToken,
        meeting,
        conferenceRecord: resolved.conferenceRecord,
        pageSize: resolved.pageSize,
        allConferenceRecords: resolved.allConferenceRecords,
        mergeDuplicateParticipants: resolved.mergeDuplicateParticipants,
        lateAfterMinutes: resolved.lateAfterMinutes,
        earlyBeforeMinutes: resolved.earlyBeforeMinutes,
      });
      if (options.json) {
        await writeCliOutput(
          options,
          JSON.stringify(
            {
              ...result,
              tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
            },
            null,
            2,
          ),
        );
        return;
      }
      if (options.format === "markdown") {
        await writeCliOutput(options, renderAttendanceMarkdown(result));
        return;
      }
      if (options.format === "csv") {
        await writeCliOutput(options, renderAttendanceCsv(result));
        return;
      }
      if (options.format && options.format !== "summary") {
        throw new Error("Unsupported format. Expected summary, markdown, or csv.");
      }
      writeAttendanceSummary(result);
      writeStdoutLine(
        "token source: %s",
        token.refreshed ? "refresh-token" : "cached-access-token",
      );
    });

  root
    .command("export")
    .description("Write Meet artifacts, attendance, transcript, and raw JSON into a folder")
    .option("--meeting <value>", "Meet URL, meeting code, or spaces/{id}")
    .option("--conference-record <name>", "Conference record name or id")
    .option("--today", "Find a Meet link on today's calendar")
    .option("--event <query>", "Find a matching calendar event with a Meet link")
    .option("--calendar <id>", "Calendar id for --today or --event", "primary")
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--page-size <n>", "Max resources per Meet API page")
    .option("--all-conference-records", "Fetch every conference record for --meeting")
    .option("--no-transcript-entries", "Skip structured transcript entry lookup")
    .option("--include-doc-bodies", "Export linked transcript and smart-note Google Docs text")
    .option("--no-merge-duplicates", "Keep duplicate participant resources as separate rows")
    .option("--late-after-minutes <n>", "Mark participants late after this many minutes", "5")
    .option("--early-before-minutes <n>", "Mark early leavers before this many minutes", "5")
    .option("--output <dir>", "Output directory")
    .option("--zip", "Also write a portable .zip archive")
    .option("--dry-run", "Fetch export data and print the manifest without writing files", false)
    .option("--json", "Print JSON output", false)
    .action(async (options: MeetArtifactOptions) => {
      const resolved = resolveArtifactTokenOptions(params.config, options);
      const token = await resolveGoogleMeetAccessToken(resolved);
      const meetingResult: { meeting?: string; calendarEvent?: GoogleMeetCalendarLookupResult } =
        resolved.conferenceRecord
          ? { meeting: resolved.meeting }
          : await resolveMeetingForToken({
              config: params.config,
              options,
              accessToken: token.accessToken,
              configuredMeeting: resolved.meeting,
            });
      const artifacts = await fetchGoogleMeetArtifacts({
        accessToken: token.accessToken,
        meeting: meetingResult.meeting,
        conferenceRecord: resolved.conferenceRecord,
        pageSize: resolved.pageSize,
        includeTranscriptEntries: resolved.includeTranscriptEntries,
        allConferenceRecords: resolved.allConferenceRecords,
        includeDocumentBodies: resolved.includeDocumentBodies,
      });
      const attendance = await fetchGoogleMeetAttendance({
        accessToken: token.accessToken,
        meeting: meetingResult.meeting,
        conferenceRecord: resolved.conferenceRecord,
        pageSize: resolved.pageSize,
        allConferenceRecords: resolved.allConferenceRecords,
        mergeDuplicateParticipants: resolved.mergeDuplicateParticipants,
        lateAfterMinutes: resolved.lateAfterMinutes,
        earlyBeforeMinutes: resolved.earlyBeforeMinutes,
      });
      const resolvedMeeting = meetingResult.meeting ?? resolved.meeting;
      const request: GoogleMeetExportRequest = {
        ...(resolvedMeeting ? { meeting: resolvedMeeting } : {}),
        ...(resolved.conferenceRecord ? { conferenceRecord: resolved.conferenceRecord } : {}),
        ...(meetingResult.calendarEvent?.event.id
          ? { calendarEventId: meetingResult.calendarEvent.event.id }
          : {}),
        ...(meetingResult.calendarEvent?.event.summary
          ? { calendarEventSummary: meetingResult.calendarEvent.event.summary }
          : {}),
        ...(options.calendar ? { calendarId: options.calendar } : {}),
        ...(resolved.pageSize !== undefined ? { pageSize: resolved.pageSize } : {}),
        includeTranscriptEntries: resolved.includeTranscriptEntries,
        includeDocumentBodies: resolved.includeDocumentBodies,
        allConferenceRecords: resolved.allConferenceRecords,
        mergeDuplicateParticipants: resolved.mergeDuplicateParticipants,
        ...(resolved.lateAfterMinutes !== undefined
          ? { lateAfterMinutes: resolved.lateAfterMinutes }
          : {}),
        ...(resolved.earlyBeforeMinutes !== undefined
          ? { earlyBeforeMinutes: resolved.earlyBeforeMinutes }
          : {}),
      };
      if (options.dryRun) {
        writeStdoutJson({
          dryRun: true,
          manifest: buildGoogleMeetExportManifest({
            artifacts,
            attendance,
            files: googleMeetExportFileNames(),
            request,
            tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
            ...(meetingResult.calendarEvent ? { calendarEvent: meetingResult.calendarEvent } : {}),
          }),
          ...(meetingResult.calendarEvent ? { calendarEvent: meetingResult.calendarEvent } : {}),
          tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
        });
        return;
      }
      const bundle = await writeMeetExportBundle({
        outputDir: options.output,
        artifacts,
        attendance,
        zip: Boolean(options.zip),
        request,
        tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
        ...(meetingResult.calendarEvent ? { calendarEvent: meetingResult.calendarEvent } : {}),
      });
      const payload = {
        ...bundle,
        ...(meetingResult.calendarEvent ? { calendarEvent: meetingResult.calendarEvent } : {}),
        tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
      };
      if (options.json) {
        writeStdoutJson(payload);
        return;
      }
      writeStdoutLine("export: %s", bundle.outputDir);
      for (const file of bundle.files) {
        writeStdoutLine("- %s", file);
      }
      if (bundle.zipFile) {
        writeStdoutLine("zip: %s", bundle.zipFile);
      }
    });

  root
    .command("status")
    .argument("[session-id]", "Meet session ID")
    .option("--json", "Print JSON output", false)
    .action(async (sessionId?: string) => {
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.status",
        payload: { sessionId },
      });
      if (delegated.ok) {
        writeStdoutJson(delegated.payload);
        return;
      }
      const rt = await params.ensureRuntime();
      writeStdoutJson(await rt.status(sessionId));
    });

  root
    .command("doctor")
    .description("Show human-readable Meet session/browser/realtime health")
    .argument("[session-id]", "Meet session ID")
    .option("--oauth", "Verify Google Meet OAuth token refresh without printing secrets", false)
    .option("--meeting <value>", "Also verify spaces.get for a Meet URL, code, or spaces/{id}")
    .option("--create-space", "Also verify spaces.create by creating a throwaway Meet space", false)
    .option("--access-token <token>", "Access token override")
    .option("--refresh-token <token>", "Refresh token override")
    .option("--client-id <id>", "OAuth client id override")
    .option("--client-secret <secret>", "OAuth client secret override")
    .option("--expires-at <ms>", "Cached access token expiry as unix epoch milliseconds")
    .option("--json", "Print JSON output", false)
    .action(async (sessionId: string | undefined, options: DoctorOptions) => {
      if (options.oauth) {
        const report = await buildOAuthDoctorReport(params.config, options);
        if (options.json) {
          writeStdoutJson(report);
          return;
        }
        writeOAuthDoctorReport(report);
        return;
      }
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.status",
        payload: { sessionId },
      });
      if (delegated.ok) {
        const status = delegated.payload as Awaited<ReturnType<GoogleMeetRuntime["status"]>>;
        if (options.json) {
          writeStdoutJson(status);
          return;
        }
        writeDoctorStatus(status);
        return;
      }
      const rt = await params.ensureRuntime();
      const status = await rt.status(sessionId);
      if (options.json) {
        writeStdoutJson(status);
        return;
      }
      writeDoctorStatus(status);
    });

  root
    .command("recover-tab")
    .description("Focus and inspect an existing Google Meet tab")
    .argument("[url]", "Optional Meet URL to match")
    .option("--transport <transport>", "Transport to inspect: chrome or chrome-node")
    .option("--json", "Print JSON output", false)
    .action(async (url: string | undefined, options: RecoverTabOptions) => {
      const rt = await params.ensureRuntime();
      const result = await rt.recoverCurrentTab({ url, transport: options.transport });
      if (options.json) {
        writeStdoutJson(result);
        return;
      }
      writeRecoverCurrentTabResult(result);
    });

  root
    .command("setup")
    .description("Show Google Meet transport setup status")
    .option("--transport <transport>", "Transport to check: chrome, chrome-node, or twilio")
    .option("--mode <mode>", "Mode to check: agent, bidi, or transcribe")
    .option("--json", "Print JSON output", false)
    .action(async (options: SetupOptions) => {
      const rt = await params.ensureRuntime();
      const status = await rt.setupStatus({ transport: options.transport, mode: options.mode });
      if (options.json) {
        writeStdoutJson(status);
        return;
      }
      writeSetupStatus(status);
    });

  root
    .command("leave")
    .argument("<session-id>", "Meet session ID")
    .action(async (sessionId: string) => {
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.leave",
        payload: { sessionId },
      });
      if (delegated.ok) {
        const result = delegated.payload as { found?: boolean };
        if (!result.found) {
          throw new Error("session not found");
        }
        writeStdoutLine("left %s", sessionId);
        return;
      }
      const rt = await params.ensureRuntime();
      const result = await rt.leave(sessionId);
      if (!result.found) {
        throw new Error("session not found");
      }
      writeStdoutLine("left %s", sessionId);
    });

  root
    .command("speak")
    .argument("<session-id>", "Meet session ID")
    .argument("[message]", "Realtime instructions to speak now")
    .action(async (sessionId: string, message?: string) => {
      const delegated = await callGoogleMeetGateway({
        callGateway,
        method: "googlemeet.speak",
        payload: { sessionId, message },
      });
      if (delegated.ok) {
        const result = delegated.payload as Awaited<ReturnType<GoogleMeetRuntime["speak"]>>;
        if (!result.found) {
          throw new Error("session not found");
        }
        if (!result.spoken) {
          throw new Error(
            result.session?.chrome?.health?.speechBlockedMessage ??
              "session has no active realtime audio bridge",
          );
        }
        writeStdoutLine("speaking on %s", sessionId);
        return;
      }
      const rt = await params.ensureRuntime();
      const result = await rt.speak(sessionId, message);
      if (!result.found) {
        throw new Error("session not found");
      }
      if (!result.spoken) {
        throw new Error(
          result.session?.chrome?.health?.speechBlockedMessage ??
            "session has no active realtime audio bridge",
        );
      }
      writeStdoutLine("speaking on %s", sessionId);
    });
}