@stephenyang/stephen 0.1.0

package/dist/index.js

@@ -0,0 +1,4239 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { mkdirSync as mkdirSync2, realpathSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import envPaths from "env-paths";
+
+// src/ak/command.ts
+import { Command } from "commander";
+import { ZodError, z as z8 } from "zod";
+import { table as table7 } from "table";
+
+// src/ak/output.ts
+import { table } from "table";
+function renderAkRecordsAsJson(records, limit) {
+  const serializedRecords = records.map((record) => ({
+    id: record.id,
+    env: record.env,
+    userId: record.userId,
+    userName: record.userName,
+    email: record.email,
+    phone: record.phone,
+    key: record.key,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  }));
+  return JSON.stringify(
+    {
+      ok: true,
+      data: serializedRecords,
+      meta: {
+        count: serializedRecords.length,
+        limit
+      }
+    },
+    null,
+    2
+  );
+}
+function renderAkErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        ...details === void 0 ? {} : { details },
+        message
+      }
+    },
+    null,
+    2
+  );
+}
+function renderAkRecordsAsTable(records) {
+  return table([
+    ["id", "env", "userId", "userName", "email", "phone", "key", "updatedAt"],
+    ...records.map((record) => [
+      record.id,
+      record.env,
+      record.userId ?? "",
+      record.userName ?? "",
+      record.email ?? "",
+      record.phone ?? "",
+      record.key,
+      record.updatedAt
+    ])
+  ]);
+}
+
+// src/ak/crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
+var ENCRYPTION_ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var PREFIX_LENGTH = 12;
+function createAkId(key) {
+  return createHash("sha1").update(key).digest("hex");
+}
+function deriveAkSearchPrefix(key, length = PREFIX_LENGTH) {
+  return key.slice(0, length);
+}
+function encryptAkKey(masterKey, key) {
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ENCRYPTION_ALGORITHM, masterKey, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const encrypted = Buffer.concat([cipher.update(key, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return [iv.toString("base64url"), tag.toString("base64url"), encrypted.toString("base64url")].join(".");
+}
+function decryptAkKey(masterKey, payload) {
+  const [ivPart, tagPart, encryptedPart] = payload.split(".");
+  if (!ivPart || !tagPart || !encryptedPart) {
+    throw new Error("Invalid encrypted API key payload.");
+  }
+  const decipher = createDecipheriv(
+    ENCRYPTION_ALGORITHM,
+    masterKey,
+    Buffer.from(ivPart, "base64url"),
+    {
+      authTagLength: AUTH_TAG_LENGTH
+    }
+  );
+  decipher.setAuthTag(Buffer.from(tagPart, "base64url"));
+  return Buffer.concat([
+    decipher.update(Buffer.from(encryptedPart, "base64url")),
+    decipher.final()
+  ]).toString("utf8");
+}
+
+// src/ak/schema.ts
+import { z } from "zod";
+
+// src/ak/types.ts
+var AK_RECOMMENDED_ENVS = [
+  "bzy-pre",
+  "bzy-prod",
+  "op-pre",
+  "op-prod",
+  "gitee",
+  "github",
+  "gitlab"
+];
+var AK_QUERY_FIELDS = [
+  "userId",
+  "userName",
+  "email",
+  "phone",
+  "key"
+];
+
+// src/ak/schema.ts
+var envRecommendationMessage = `Recommended values: ${AK_RECOMMENDED_ENVS.join(", ")}.`;
+var akEnvSchema = z.string().transform((value, context) => {
+  try {
+    return normalizeAkEnv(value);
+  } catch (error) {
+    context.addIssue({
+      code: "custom",
+      message: error.message
+    });
+    return z.NEVER;
+  }
+});
+function normalizeAkKey(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error("API key cannot be empty.");
+  }
+  return normalized;
+}
+function normalizeAkEnv(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error(`Environment is required. ${envRecommendationMessage}`);
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(normalized)) {
+    throw new Error(
+      `Environment must use letters, numbers, ".", "_" or "-". ${envRecommendationMessage}`
+    );
+  }
+  return normalized;
+}
+function maskKey(value) {
+  if (value.length <= 4) {
+    return "*".repeat(value.length);
+  }
+  if (value.length <= 8) {
+    return `${value.slice(0, 2)}${"*".repeat(value.length - 4)}${value.slice(-2)}`;
+  }
+  return `${value.slice(0, 4)}${"*".repeat(value.length - 8)}${value.slice(-4)}`;
+}
+var nullableTextField = z.string().trim().min(1).optional().transform((value) => value ?? void 0);
+var addAkRecordInputSchema = z.object({
+  email: nullableTextField,
+  env: akEnvSchema,
+  key: z.string().transform(normalizeAkKey),
+  phone: nullableTextField,
+  userId: nullableTextField,
+  userName: nullableTextField
+});
+var listAkRecordsInputSchema = z.object({
+  env: akEnvSchema.optional(),
+  field: z.string().trim().optional(),
+  limit: z.number().int().positive().max(100).default(50),
+  query: z.string().trim().min(1).optional()
+});
+function parseAkQueryFields(value) {
+  if (!value) {
+    return [...AK_QUERY_FIELDS];
+  }
+  return value.split(",").map((field) => {
+    const normalized = field.trim();
+    if (!AK_QUERY_FIELDS.includes(normalized)) {
+      throw new Error(`Unsupported query field: ${normalized}.`);
+    }
+    return normalized;
+  });
+}
+
+// src/ak/service.ts
+var AkServiceError = class extends Error {
+  code;
+  exitCode;
+  constructor(code, message, exitCode) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.name = "AkServiceError";
+  }
+};
+var AkService = class {
+  #masterKey;
+  #now;
+  #repository;
+  constructor(dependencies) {
+    this.#masterKey = dependencies.masterKey;
+    this.#now = dependencies.now;
+    this.#repository = dependencies.repository;
+  }
+  add(input2) {
+    const parsed = addAkRecordInputSchema.parse(input2);
+    const key = normalizeAkKey(parsed.key);
+    const id = createAkId(key);
+    const now = this.#now();
+    this.#repository.insert({
+      createdAt: now,
+      email: normalizeNullableFieldForInsert(parsed.email),
+      env: parsed.env,
+      id,
+      keyCiphertext: encryptAkKey(this.#masterKey, key),
+      keySearchPrefix: deriveAkSearchPrefix(key),
+      phone: normalizeNullableFieldForInsert(parsed.phone),
+      updatedAt: now,
+      userId: normalizeNullableFieldForInsert(parsed.userId),
+      userName: normalizeNullableFieldForInsert(parsed.userName)
+    });
+    const record = this.#repository.getById(id);
+    if (!record) {
+      throw new AkServiceError("STORAGE_ERROR", "Failed to load the newly created record.", 6);
+    }
+    return this.#toView(record, Boolean(input2.rawKey));
+  }
+  get(input2) {
+    const record = this.#findRecord(input2);
+    if (!record) {
+      throw new AkServiceError("RECORD_NOT_FOUND", "No API key record matched the query.", 3);
+    }
+    return this.#toView(record, Boolean(input2.rawKey));
+  }
+  list(input2) {
+    const fields = parseFields(input2.field);
+    const limit = input2.limit ?? 50;
+    const filters = {
+      fields,
+      limit,
+      ...input2.env ? { env: input2.env } : {},
+      ...input2.query ? { query: input2.query } : {}
+    };
+    const results = this.#repository.list(filters);
+    return results.map((record) => this.#toView(record, Boolean(input2.rawKey)));
+  }
+  update(input2) {
+    const record = this.#findRecord(input2);
+    if (!record) {
+      throw new AkServiceError("RECORD_NOT_FOUND", "No API key record matched the query.", 3);
+    }
+    const normalizedEmail = normalizeNullableField(input2.email);
+    const normalizedPhone = normalizeNullableField(input2.phone);
+    const normalizedUserId = normalizeNullableField(input2.userId);
+    const normalizedUserName = normalizeNullableField(input2.userName);
+    const updated = this.#repository.updateMetadata({
+      ...normalizedEmail === void 0 ? {} : { email: normalizedEmail },
+      id: record.id,
+      ...normalizedPhone === void 0 ? {} : { phone: normalizedPhone },
+      updatedAt: this.#now(),
+      ...normalizedUserId === void 0 ? {} : { userId: normalizedUserId },
+      ...normalizedUserName === void 0 ? {} : { userName: normalizedUserName }
+    });
+    if (!updated) {
+      throw new AkServiceError("STORAGE_ERROR", "Failed to update the API key record.", 6);
+    }
+    return this.#toView(updated, Boolean(input2.rawKey));
+  }
+  delete(input2) {
+    const record = this.#findRecord(input2);
+    if (!record) {
+      throw new AkServiceError("RECORD_NOT_FOUND", "No API key record matched the query.", 3);
+    }
+    return this.#repository.deleteById(record.id);
+  }
+  #findRecord(input2) {
+    if (input2.id) {
+      return this.#repository.getById(input2.id);
+    }
+    if (input2.env && input2.key) {
+      const normalizedKey = normalizeAkKey(input2.key);
+      return this.#repository.getByEnvAndId(input2.env, createAkId(normalizedKey));
+    }
+    throw new AkServiceError(
+      "INVALID_ARGUMENT",
+      "Provide either --id or the pair of --env and --key.",
+      2
+    );
+  }
+  #toView(record, rawKey) {
+    const key = decryptAkKey(this.#masterKey, record.keyCiphertext);
+    return {
+      createdAt: record.createdAt,
+      email: record.email,
+      env: record.env,
+      id: record.id,
+      key: rawKey ? key : maskKey(key),
+      phone: record.phone,
+      updatedAt: record.updatedAt,
+      userId: record.userId,
+      userName: record.userName
+    };
+  }
+};
+function normalizeNullableField(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length === 0 ? null : normalized;
+}
+function normalizeNullableFieldForInsert(value) {
+  return normalizeNullableField(value) ?? null;
+}
+function parseFields(value) {
+  try {
+    return parseAkQueryFields(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid query fields.";
+    throw new AkServiceError("INVALID_ARGUMENT", message, 2);
+  }
+}
+
+// src/ak/runtime.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { z as z2 } from "zod";
+var AK_DB_PATH_ENV_VAR = "STEPHEN_AK_DB_PATH";
+var LEGACY_AK_DB_PATH_ENV_VAR = "STEPHEN_CLI_AK_DB_PATH";
+var AK_CONFIG_FILE_NAME = "config.json";
+var CONFIG_KEYS = ["ak.dbPath"];
+var AkConfigError = class extends Error {
+  code = "CONFIG_ERROR";
+  exitCode = 2;
+  constructor(message) {
+    super(message);
+    this.name = "AkConfigError";
+  }
+};
+var AkStorageInitError = class extends Error {
+  code = "STORAGE_ERROR";
+  exitCode = 6;
+  constructor(path, cause) {
+    const detail = cause instanceof Error ? cause.message : "Unknown storage error.";
+    super(
+      `Failed to open the ak database at "${path}". Check ${formatAkDbPathEnvVarHelp()}, the local config file, and the parent directory permissions. Details: ${detail}`
+    );
+    this.name = "AkStorageInitError";
+  }
+};
+var akConfigSchema = z2.object({
+  ak: z2.object({
+    dbPath: z2.string().optional()
+  }).optional()
+}).passthrough();
+function getAkConfigFilePath(configDir) {
+  return join(configDir, AK_CONFIG_FILE_NAME);
+}
+function loadAkConfig(configDir) {
+  const configFilePath = getAkConfigFilePath(configDir);
+  if (!existsSync(configFilePath)) {
+    return {};
+  }
+  return parseAkConfig(readFileSync(configFilePath, "utf8"), configFilePath);
+}
+function saveAkConfig(configDir, config) {
+  const configFilePath = getAkConfigFilePath(configDir);
+  mkdirSync(dirname(configFilePath), { recursive: true });
+  writeFileSync(`${configFilePath}`, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function parseAkConfig(contents, configFilePath = AK_CONFIG_FILE_NAME) {
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(contents);
+  } catch {
+    throw new AkConfigError(
+      `Failed to parse the local config file at "${configFilePath}". Fix the JSON or set ${formatAkDbPathEnvVarHelp()} to the full ak.db path on this machine.`
+    );
+  }
+  const parsed = akConfigSchema.safeParse(parsedJson);
+  if (!parsed.success) {
+    throw new AkConfigError(
+      `Invalid ak config in "${configFilePath}". Expected ak.dbPath to be a string when provided. Fix the config file or set ${formatAkDbPathEnvVarHelp()} to the full ak.db path on this machine.`
+    );
+  }
+  return parsed.data;
+}
+function resolveAkDatabasePath(input2) {
+  const configPath = normalizeConfiguredPath(input2.config.ak?.dbPath, "ak.dbPath");
+  if (configPath) {
+    return {
+      path: configPath,
+      source: "config"
+    };
+  }
+  const envPath = getConfiguredAkDbPathFromEnv(input2.env);
+  if (envPath) {
+    return {
+      path: normalizeConfiguredPath(envPath.value, envPath.source),
+      source: "env"
+    };
+  }
+  return {
+    path: join(input2.defaultDataDir, "ak.db"),
+    source: "default"
+  };
+}
+function getConfigEntry(key, input2) {
+  assertSupportedConfigKey(key);
+  const config = loadAkConfig(input2.configDir);
+  const resolved = resolveAkDatabasePath({
+    config,
+    defaultDataDir: input2.dataDir,
+    env: input2.env
+  });
+  const envValue = normalizeResolvedValue(getConfiguredAkDbPathFromEnv(input2.env)?.value);
+  const fileValue = normalizeResolvedValue(config.ak?.dbPath);
+  return {
+    configFilePath: getAkConfigFilePath(input2.configDir),
+    defaultValue: join(input2.dataDir, "ak.db"),
+    envValue,
+    fileValue,
+    key,
+    source: resolved.source,
+    value: resolved.path
+  };
+}
+function listConfigEntries(input2) {
+  return CONFIG_KEYS.map((key) => getConfigEntry(key, input2));
+}
+function setConfigValue(key, value, input2) {
+  assertSupportedConfigKey(key);
+  const normalizedValue = normalizeConfiguredPath(value, key);
+  const config = loadAkConfig(input2.configDir);
+  const nextConfig = {
+    ...config,
+    ak: {
+      ...config.ak ?? {},
+      dbPath: normalizedValue
+    }
+  };
+  saveAkConfig(input2.configDir, nextConfig);
+  return nextConfig;
+}
+function assertSupportedConfigKey(key) {
+  if (!CONFIG_KEYS.includes(key)) {
+    throw new AkConfigError(
+      `Unsupported config key: ${key}. Supported keys: ${CONFIG_KEYS.join(", ")}.`
+    );
+  }
+}
+function normalizeConfiguredPath(value, source) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new AkConfigError(
+      `${source} is configured but empty. Set it to the full ak.db path, or remove it to fall back to the next storage path source.`
+    );
+  }
+  return normalized;
+}
+function normalizeResolvedValue(value) {
+  if (value === void 0) {
+    return null;
+  }
+  return value.trim();
+}
+function getConfiguredAkDbPathFromEnv(env) {
+  const primaryValue = env[AK_DB_PATH_ENV_VAR];
+  if (primaryValue !== void 0) {
+    return {
+      source: AK_DB_PATH_ENV_VAR,
+      value: primaryValue
+    };
+  }
+  const legacyValue = env[LEGACY_AK_DB_PATH_ENV_VAR];
+  if (legacyValue !== void 0) {
+    return {
+      source: LEGACY_AK_DB_PATH_ENV_VAR,
+      value: legacyValue
+    };
+  }
+  return void 0;
+}
+function formatAkDbPathEnvVarHelp() {
+  return `${AK_DB_PATH_ENV_VAR} (preferred) or ${LEGACY_AK_DB_PATH_ENV_VAR} (legacy)`;
+}
+
+// src/disk/command.ts
+import { z as z3 } from "zod";
+
+// src/disk/output.ts
+import { table as table2 } from "table";
+function renderDiskCleanupReportAsJson(report) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: report,
+      meta: {
+        count: report.targets.length,
+        estimatedReclaimBytes: report.estimatedReclaimBytes,
+        estimatedReclaimGB: report.estimatedReclaimGB
+      }
+    },
+    null,
+    2
+  );
+}
+function renderDiskCleanupReportAsTable(report) {
+  const targetTable = table2([
+    ["label", "status", "sizeGB", "exists", "requiresAdmin", "path"],
+    ...report.targets.map((target) => [
+      target.label,
+      target.status,
+      String(target.sizeGB),
+      target.exists ? "yes" : "no",
+      target.requiresAdministrator ? "yes" : "no",
+      target.path
+    ])
+  ]);
+  if (!report.downloads) {
+    return targetTable;
+  }
+  return `${targetTable}
+Downloads top entries
+${table2([
+    ["kind", "sizeGB", "path"],
+    ...report.downloads.topEntries.map((entry) => [entry.kind, String(entry.sizeGB), entry.path])
+  ])}`;
+}
+
+// src/disk/command.ts
+var diskCleanupOptionsSchema = z3.object({
+  apply: z3.boolean().default(false),
+  confirm: z3.boolean().default(false),
+  disableHibernate: z3.boolean().default(false),
+  format: z3.enum(["json", "table"]).default("json"),
+  level: z3.enum(["safe", "dev", "system", "deep"]).default("safe")
+});
+function registerDiskCommands(program, dependencies) {
+  const disk = program.command("disk").description("Inspect and clean conservative disk caches.");
+  disk.command("cleanup").option("--apply", "execute cleanup instead of previewing it").option("--confirm", "confirm apply for system or deep cleanup levels").option("--disable-hibernate", "disable Windows hibernation during apply mode").option("--format <format>", "output format", "json").option("--level <level>", "cleanup level: safe, dev, system, or deep", "safe").option("-t, --table", "render as a table").action(async (options) => {
+    const parsed = diskCleanupOptionsSchema.parse(applyDiskTableShortcut(options));
+    const report = await dependencies.createDiskCleanupService().cleanup({
+      apply: parsed.apply,
+      confirm: parsed.confirm,
+      disableHibernate: parsed.disableHibernate,
+      level: parsed.level
+    });
+    if (parsed.format === "table") {
+      dependencies.stdout(`${renderDiskCleanupReportAsTable(report)}
+`);
+      return;
+    }
+    dependencies.stdout(`${renderDiskCleanupReportAsJson(report)}
+`);
+  });
+}
+function applyDiskTableShortcut(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  if (options.format) {
+    return {
+      ...options,
+      format: options.format
+    };
+  }
+  throw new Error("Output format is required for this command.");
+}
+
+// src/disk/service.ts
+import { win32 } from "path";
+var DiskCleanupServiceError = class extends Error {
+  code;
+  details;
+  exitCode;
+  constructor(code, message, exitCode = 2, details) {
+    super(message);
+    this.code = code;
+    if (details) {
+      this.details = details;
+    }
+    this.exitCode = exitCode;
+  }
+};
+var DiskCleanupService = class {
+  runtime;
+  systemRoot;
+  userProfileRoot;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+    this.systemRoot = dependencies.systemRoot;
+    this.userProfileRoot = dependencies.userProfileRoot;
+  }
+  async cleanup(options) {
+    if (requiresConfirmation(options.level) && options.apply && !options.confirm) {
+      throw new DiskCleanupServiceError(
+        "DISK_CLEANUP_CONFIRMATION_REQUIRED",
+        "Disk cleanup level requires --confirm before apply."
+      );
+    }
+    const targetDefinitions = this.getTargets(options.level);
+    const targets = [];
+    const failures = [];
+    let estimatedReclaimBytes = 0;
+    for (const target of targetDefinitions) {
+      const inspection = target.action === "run-command" ? { exists: true, isDirectory: false, sizeBytes: 0 } : await this.runtime.inspectPath(target.path);
+      estimatedReclaimBytes += inspection.sizeBytes;
+      let status = inspection.exists ? options.apply ? "cleaned" : "planned" : "missing";
+      let error;
+      if (options.apply && inspection.exists) {
+        try {
+          if (target.action === "clear-directory-contents") {
+            await this.runtime.clearDirectoryContents(target.path);
+          }
+          if (target.action === "run-command") {
+            await this.runtime.runCommand(target.command, target.args ?? []);
+          }
+          if (target.action === "inspect-only") {
+            status = "planned";
+          }
+        } catch (cause) {
+          error = getErrorMessage(cause);
+          failures.push(`${target.label}: ${error}`);
+          status = "failed";
+        }
+      }
+      targets.push({
+        action: target.action,
+        ...target.command ? { command: target.command } : {},
+        ...target.args ? { args: target.args } : {},
+        exists: inspection.exists,
+        label: target.label,
+        path: target.path,
+        requiresAdministrator: target.requiresAdministrator,
+        sizeBytes: inspection.sizeBytes,
+        sizeGB: bytesToGb(inspection.sizeBytes),
+        status,
+        ...error ? { error } : {}
+      });
+    }
+    const hibernation = {
+      requested: options.disableHibernate,
+      status: "skipped"
+    };
+    if (options.apply && options.disableHibernate) {
+      try {
+        await this.runtime.disableHibernation();
+        hibernation.status = "disabled";
+      } catch (error) {
+        hibernation.status = "failed";
+        hibernation.error = getErrorMessage(error);
+        failures.push(`hibernation: ${hibernation.error}`);
+      }
+    }
+    const report = {
+      ...options.level === "deep" ? { downloads: await this.getDownloadsReport() } : {},
+      estimatedReclaimBytes,
+      estimatedReclaimGB: bytesToGb(estimatedReclaimBytes),
+      hibernation,
+      level: options.level,
+      mode: options.apply ? "apply" : "preview",
+      systemRoot: this.systemRoot,
+      targets,
+      userProfileRoot: this.userProfileRoot
+    };
+    if (failures.length > 0) {
+      throw new DiskCleanupServiceError(
+        "DISK_CLEANUP_ERROR",
+        "Disk cleanup encountered failures.",
+        2,
+        {
+          report
+        }
+      );
+    }
+    ;
+    return report;
+  }
+  async getDownloadsReport() {
+    const path = win32.join(this.userProfileRoot, "Downloads");
+    return {
+      path,
+      topEntries: await this.runtime.listTopEntriesBySize(path, 100)
+    };
+  }
+  getTargets(level) {
+    if (level === "safe") {
+      return this.getSafeTargets();
+    }
+    if (level === "dev") {
+      return dedupeTargets([...this.getSafeTargets(), ...this.getDevTargets()]);
+    }
+    if (level === "system") {
+      return dedupeTargets([...this.getSafeTargets(), ...this.getSystemTargets()]);
+    }
+    return dedupeTargets([...this.getSafeTargets(), ...this.getDevTargets(), ...this.getSystemTargets()]);
+  }
+  getSafeTargets() {
+    return [
+      {
+        action: "clear-directory-contents",
+        label: "npm cache",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "npm-cache"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "NuGet cache",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "NuGet"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "Generic cache",
+        path: win32.join(this.userProfileRoot, ".cache"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "Maven repository cache",
+        path: win32.join(this.userProfileRoot, ".m2"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "User temp",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "Temp"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "Windows Update download cache",
+        path: win32.join(this.systemRoot, "SoftwareDistribution", "Download"),
+        requiresAdministrator: true
+      }
+    ];
+  }
+  getDevTargets() {
+    return [
+      {
+        action: "clear-directory-contents",
+        label: "Gradle cache",
+        path: win32.join(this.userProfileRoot, ".gradle", "caches"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "pnpm store",
+        path: win32.join(this.userProfileRoot, ".pnpm-store"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "pnpm local store",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "pnpm", "store"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "Yarn cache",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "Yarn", "Cache"),
+        requiresAdministrator: false
+      },
+      {
+        action: "clear-directory-contents",
+        label: "pip cache",
+        path: win32.join(this.userProfileRoot, "AppData", "Local", "pip", "Cache"),
+        requiresAdministrator: false
+      }
+    ];
+  }
+  getSystemTargets() {
+    return [
+      {
+        action: "clear-directory-contents",
+        label: "Windows temp",
+        path: win32.join(this.systemRoot, "Temp"),
+        requiresAdministrator: true
+      },
+      {
+        action: "run-command",
+        args: ["/Online", "/Cleanup-Image", "/StartComponentCleanup"],
+        command: "dism.exe",
+        label: "DISM component cleanup",
+        path: "dism.exe /Online /Cleanup-Image /StartComponentCleanup",
+        requiresAdministrator: true
+      }
+    ];
+  }
+};
+function bytesToGb(value) {
+  return Number((value / 1024 ** 3).toFixed(2));
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function requiresConfirmation(level) {
+  return level === "system" || level === "deep";
+}
+function dedupeTargets(targets) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const target of targets) {
+    const key = `${target.action}:${target.command ?? target.path}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(target);
+  }
+  return result;
+}
+
+// src/video/command.ts
+import { z as z4 } from "zod";
+
+// src/video/sniff/browser-provider.ts
+var BrowserVideoSniffProvider = class {
+  runtime;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+  }
+  sniff(sourceUrl, options) {
+    return this.runtime.launchBrowserSniffer(sourceUrl, options);
+  }
+};
+
+// src/video/sniff/candidate.ts
+function createVideoCandidate(type, url, origin, confidence = 0.5) {
+  return {
+    confidence,
+    mimeType: type === "m3u8" ? "application/vnd.apple.mpegurl" : "video/mp4",
+    origin,
+    type,
+    url
+  };
+}
+function rankVideoCandidates(candidates) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const existing = deduped.get(candidate.url);
+    if (!existing || (candidate.confidence ?? 0) > (existing.confidence ?? 0)) {
+      deduped.set(candidate.url, candidate);
+    }
+  }
+  return [...deduped.values()].sort((left, right) => {
+    const confidenceDelta = (right.confidence ?? 0) - (left.confidence ?? 0);
+    if (confidenceDelta !== 0) {
+      return confidenceDelta;
+    }
+    if (left.type === right.type) {
+      return 0;
+    }
+    return left.type === "m3u8" ? -1 : 1;
+  });
+}
+function extractVideoCandidatesFromText(text, origin) {
+  const matches = text.matchAll(/https?:\/\/[^\s"'<>]+?\.(m3u8|mp4)(?:\?[^\s"'<>]*)?/gi);
+  return rankVideoCandidates(
+    [...matches].map(
+      (match) => createVideoCandidate(match[1]?.toLowerCase() === "m3u8" ? "m3u8" : "mp4", match[0], origin, origin === "html" ? 0.75 : 0.65)
+    )
+  );
+}
+
+// src/video/utils.ts
+function optional(key, value) {
+  return value !== void 0 && value !== null && value !== "" ? { [key]: value } : {};
+}
+
+// src/video/sniff/service.ts
+var VideoSniffService = class {
+  browserProvider;
+  httpProvider;
+  constructor(dependencies) {
+    this.browserProvider = dependencies.browserProvider;
+    this.httpProvider = dependencies.httpProvider;
+  }
+  async sniff(options) {
+    const providerOptions = buildProviderOptions(options);
+    if (options.mode === "http") {
+      return this.createResult("http", options.sourceUrl, await this.httpProvider(options.sourceUrl, providerOptions));
+    }
+    if (options.mode === "browser") {
+      return this.createResult(
+        "browser",
+        options.sourceUrl,
+        await this.browserProvider(options.sourceUrl, providerOptions)
+      );
+    }
+    try {
+      return this.createResult(
+        "browser",
+        options.sourceUrl,
+        await this.browserProvider(options.sourceUrl, providerOptions)
+      );
+    } catch (error) {
+      if (error instanceof Error && "recoverable" in error && error.recoverable === true) {
+        return this.createResult("http", options.sourceUrl, await this.httpProvider(options.sourceUrl, providerOptions));
+      }
+      throw error;
+    }
+  }
+  createResult(mode, sourceUrl, candidates) {
+    return {
+      candidates: rankVideoCandidates(candidates),
+      mode,
+      sourceUrl
+    };
+  }
+};
+function buildProviderOptions(options) {
+  return {
+    ...optional("noProxy", options.noProxy),
+    ...optional("proxyUrl", options.proxyUrl)
+  };
+}
+
+// src/video/types.ts
+var VideoCommandError = class extends Error {
+  code;
+  details;
+  exitCode;
+  recoverable;
+  constructor(code, message, exitCode = 2, details, recoverable = false) {
+    super(message);
+    this.code = code;
+    if (details !== void 0) {
+      this.details = details;
+    }
+    this.exitCode = exitCode;
+    this.recoverable = recoverable;
+  }
+};
+
+// src/video/sniff/http-provider.ts
+var HttpVideoSniffProvider = class {
+  runtime;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+  }
+  async sniff(sourceUrl, options) {
+    const response = await this.runtime.fetch(sourceUrl);
+    if (!response.ok) {
+      throw new VideoCommandError(
+        "VIDEO_SNIFF_FAILED",
+        `Failed to inspect ${sourceUrl}. HTTP ${response.status}.`
+      );
+    }
+    const text = await response.text();
+    return extractVideoCandidatesFromText(text, "html");
+  }
+};
+
+// src/video/download/direct-driver.ts
+import { basename, win32 as win322 } from "path";
+import { SingleBar } from "cli-progress";
+
+// src/video/download/media-request.ts
+function createMediaRequestInit(sourceUrl) {
+  const url = new URL(sourceUrl);
+  return {
+    headers: {
+      referer: `${url.protocol}//${url.host}/`,
+      "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36"
+    }
+  };
+}
+
+// src/video/download/direct-driver.ts
+async function fetchWithProxy(url, runtime, options) {
+  const init = createMediaRequestInit(url);
+  if (options?.noProxy) {
+    return await runtime.fetch(url, init);
+  }
+  const proxyUrl = options?.proxyUrl ?? process.env.HTTP_PROXY ?? process.env.HTTPS_PROXY;
+  if (!proxyUrl) {
+    return await runtime.fetch(url, init);
+  }
+  try {
+    const mod = await import("https-proxy-agent");
+    const response = await runtime.fetch(url, { ...init, agent: new mod.HttpsProxyAgent(proxyUrl) });
+    return response;
+  } catch (error) {
+    console.warn(`[stephen] Proxy connection failed (${proxyUrl}), falling back to direct connection: ${error instanceof Error ? error.message : String(error)}`);
+    return await runtime.fetch(url, init);
+  }
+}
+var DirectVideoDownloadDriver = class {
+  runtime;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+  }
+  async download(options) {
+    let response;
+    try {
+      response = await fetchWithProxy(
+        options.sourceUrl,
+        this.runtime,
+        buildProxyOptions(options)
+      );
+    } catch (error) {
+      throw new VideoCommandError(
+        "VIDEO_DOWNLOAD_FAILED",
+        `Failed to download ${options.sourceUrl}.`,
+        2,
+        {
+          cause: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+    if (!response.ok) {
+      throw new VideoCommandError(
+        "VIDEO_DOWNLOAD_FAILED",
+        `Failed to download ${options.sourceUrl}. HTTP ${response.status}.`
+      );
+    }
+    const outputPath = options.outputPath ?? win322.join(options.outputDir ?? ".", inferFileName(options.sourceUrl));
+    const contentLength = response.headers.get("content-length");
+    const totalBytes = contentLength ? parseInt(contentLength, 10) : void 0;
+    let buffer;
+    if (response.body && totalBytes && totalBytes > 0) {
+      buffer = await this.downloadWithProgress(response.body, totalBytes, outputPath);
+    } else {
+      buffer = await this.downloadAsBuffer(response);
+    }
+    await this.runtime.writeFile(outputPath, buffer);
+    const downloadedBytes = buffer.byteLength;
+    if (downloadedBytes > 0) {
+      console.error(`Downloaded ${formatBytes(downloadedBytes)} to ${outputPath}`);
+    }
+    return {
+      bytesWritten: buffer.byteLength,
+      mediaType: "mp4",
+      outputPath,
+      sourceUrl: options.sourceUrl
+    };
+  }
+  /* c8 ignore start */
+  async downloadWithProgress(body, totalBytes, _outputPath) {
+    const reader = body.getReader();
+    const chunks = [];
+    let receivedBytes = 0;
+    const startTime = Date.now();
+    const progressBar = new SingleBar({
+      format: createProgressFormatter(startTime, 24),
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true,
+      fps: 10,
+      barsize: 24
+    });
+    progressBar.start(totalBytes, 0);
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+        receivedBytes += value.length;
+        progressBar.update(receivedBytes);
+      }
+    } finally {
+      progressBar.stop();
+      reader.releaseLock();
+    }
+    return Buffer.concat(chunks);
+  }
+  async downloadAsBuffer(response) {
+    const payload = await response.arrayBuffer();
+    return payload instanceof Uint8Array ? Buffer.from(payload) : Buffer.from(payload);
+  }
+};
+function createProgressFormatter(startTime, barsize) {
+  return (_options, params) => {
+    const elapsed = (Date.now() - startTime) / 1e3;
+    const speed = elapsed > 0 ? params.value / elapsed : 0;
+    const completeCount = Math.round(params.progress * barsize);
+    const bar = "\u2588".repeat(completeCount) + "\u2591".repeat(barsize - completeCount);
+    const percentage = (params.progress * 100).toFixed(1);
+    return `Downloading ${bar} ${percentage}% | ${formatBytes(speed)}/s | ETA ${formatETA(params.eta)} | ${formatBytes(params.value)} / ${formatBytes(params.total)}`;
+  };
+}
+function inferFileName(sourceUrl) {
+  const name = basename(new URL(sourceUrl).pathname);
+  return name || "video.mp4";
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function formatETA(seconds) {
+  if (!isFinite(seconds) || seconds <= 0) return "--:--";
+  const s = Math.round(seconds);
+  if (s >= 3600) {
+    const h = Math.floor(s / 3600);
+    const m2 = Math.floor(s % 3600 / 60);
+    const sec2 = s % 60;
+    return `${h}:${String(m2).padStart(2, "0")}:${String(sec2).padStart(2, "0")}`;
+  }
+  const m = Math.floor(s / 60);
+  const sec = s % 60;
+  return `${m}:${String(sec).padStart(2, "0")}`;
+}
+function buildProxyOptions(options) {
+  return {
+    ...options.noProxy === void 0 ? {} : { noProxy: options.noProxy },
+    ...options.proxyUrl === void 0 ? {} : { proxyUrl: options.proxyUrl }
+  };
+}
+
+// src/video/download/hls-driver.ts
+import { basename as basename2, extname, win32 as win323 } from "path";
+var HlsVideoDownloadDriver = class {
+  runtime;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+  }
+  async download(options) {
+    const playlistResponse = await this.runtime.fetch(
+      options.sourceUrl,
+      createMediaRequestInit(options.sourceUrl)
+    );
+    if (!playlistResponse.ok) {
+      throw new VideoCommandError(
+        "VIDEO_DOWNLOAD_FAILED",
+        `Failed to download ${options.sourceUrl}. HTTP ${playlistResponse.status}.`
+      );
+    }
+    const playlist = await playlistResponse.text();
+    const segmentUrls = parsePlaylistResourceUrls(playlist, options.sourceUrl);
+    const chunks = [];
+    const segmentResponses = await Promise.all(
+      segmentUrls.map((segmentUrl) => this.runtime.fetch(segmentUrl, createMediaRequestInit(segmentUrl)))
+    );
+    for (let i = 0; i < segmentResponses.length; i++) {
+      const segmentResponse = segmentResponses[i];
+      const segmentUrl = segmentUrls[i];
+      if (!segmentResponse || !segmentUrl) {
+        throw new VideoCommandError(
+          "VIDEO_DOWNLOAD_FAILED",
+          `Failed to download segment ${i}.`
+        );
+      }
+      if (!segmentResponse.ok) {
+        throw new VideoCommandError(
+          "VIDEO_DOWNLOAD_FAILED",
+          `Failed to download ${segmentUrl}. HTTP ${segmentResponse.status}.`
+        );
+      }
+      const payload = await segmentResponse.arrayBuffer();
+      chunks.push(payload instanceof Uint8Array ? Buffer.from(payload) : Buffer.from(payload));
+    }
+    const merged = Buffer.concat(chunks);
+    const outputPath = options.outputPath ?? win323.join(options.outputDir ?? ".", `${stripExtension(basename2(new URL(options.sourceUrl).pathname))}.ts`);
+    await this.runtime.writeFile(outputPath, merged);
+    return {
+      bytesWritten: merged.byteLength,
+      mediaType: "m3u8",
+      outputPath,
+      sourceUrl: options.sourceUrl
+    };
+  }
+};
+function stripExtension(value) {
+  const extension = extname(value);
+  return extension.length === 0 ? value : value.slice(0, -extension.length);
+}
+function parsePlaylistResourceUrls(playlist, sourceUrl) {
+  const urls = [];
+  for (const rawLine of playlist.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (line.length === 0) {
+      continue;
+    }
+    const mapUri = /^#EXT-X-MAP:.*URI="([^"]+)"/u.exec(line)?.[1];
+    if (mapUri) {
+      urls.push(new URL(mapUri, sourceUrl).toString());
+      continue;
+    }
+    if (!line.startsWith("#")) {
+      urls.push(new URL(line, sourceUrl).toString());
+    }
+  }
+  return urls;
+}
+
+// src/video/download/browser-driver.ts
+import { join as join2 } from "path";
+var BrowserDownloadDriver = class {
+  async download(options) {
+    const outputPath = options.outputPath ?? join2(options.outputDir ?? ".", this.inferFileName(options.sourceUrl));
+    const { chromium } = await this.loadPlaywright();
+    if (!chromium) {
+      throw new VideoCommandError(
+        "VIDEO_BROWSER_UNAVAILABLE",
+        "Browser download requires Playwright Chromium support.",
+        2,
+        void 0,
+        true
+      );
+    }
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const context = await browser.newContext();
+      const page = await context.newPage();
+      const downloadPromise = page.waitForEvent("download");
+      await page.goto(options.sourceUrl, { waitUntil: "load" });
+      await page.waitForTimeout(2e3);
+      const download = await downloadPromise;
+      await download.saveAs(outputPath);
+      return {
+        mediaType: "mp4",
+        outputPath,
+        sourceUrl: options.sourceUrl
+      };
+    } finally {
+      await browser.close();
+    }
+  }
+  async loadPlaywright() {
+    try {
+      return await loadOptionalModule("playwright");
+    } catch {
+      throw new VideoCommandError(
+        "VIDEO_BROWSER_UNAVAILABLE",
+        "Browser download requires Playwright. Install it with: npm install playwright",
+        2,
+        void 0,
+        true
+      );
+    }
+  }
+  inferFileName(sourceUrl) {
+    try {
+      const url = new URL(sourceUrl);
+      const name = url.pathname.split("/").pop();
+      return name && name.length > 0 ? name : "video.mp4";
+    } catch {
+      return "video.mp4";
+    }
+  }
+};
+var loadOptionalModule = new Function(
+  "specifier",
+  "return import(specifier);"
+);
+
+// src/video/download/resolver.ts
+function encodeUrlPath(pathname) {
+  const segments = pathname.split("/");
+  return segments.map((segment) => {
+    if (segment.length > 0 && segment.charCodeAt(0) > 127) {
+      return encodeURIComponent(segment);
+    }
+    return segment;
+  }).join("/");
+}
+function classifyVideoInput(input2) {
+  let url;
+  try {
+    url = new URL(input2);
+  } catch {
+    const urlObj = new URL(input2.startsWith("http") ? input2 : `https://${input2}`);
+    urlObj.pathname = encodeUrlPath(urlObj.pathname);
+    url = urlObj;
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new VideoCommandError("VIDEO_UNSUPPORTED_INPUT", `Unsupported video input: ${input2}`);
+  }
+  if (/\.m3u8(?:\?|$)/i.test(url.href)) {
+    return {
+      kind: "m3u8",
+      url: url.href
+    };
+  }
+  if (/\.mp4(?:\?|$)/i.test(url.href)) {
+    return {
+      kind: "mp4",
+      url: url.href
+    };
+  }
+  return {
+    kind: "page",
+    url: url.href
+  };
+}
+
+// src/video/download/service.ts
+var VideoDownloadService = class {
+  directDriver;
+  hlsDriver;
+  sniffService;
+  browserDriver;
+  constructor(dependencies) {
+    this.directDriver = dependencies.directDriver;
+    this.hlsDriver = dependencies.hlsDriver;
+    this.sniffService = dependencies.sniffService;
+    this.browserDriver = dependencies.browserDriver;
+  }
+  async download(options) {
+    const classified = classifyVideoInput(options.input);
+    if (classified.kind === "page" && this.browserDriver) {
+      const sniffed2 = await this.sniffService.sniff({
+        mode: options.mode,
+        sourceUrl: classified.url,
+        ...buildProxyOptions2(options)
+      });
+      const candidate2 = sniffed2.candidates[0];
+      if (!candidate2) {
+        throw new VideoCommandError(
+          "VIDEO_NO_CANDIDATE",
+          "No supported media candidate was detected for the provided input."
+        );
+      }
+      if (candidate2.type === "m3u8") {
+        return this.hlsDriver.download(buildDownloadTargetOptions(options, candidate2.url));
+      }
+      return this.browserDriver.download(buildDownloadTargetOptions(options, candidate2.url));
+    }
+    if (classified.kind === "m3u8") {
+      return this.hlsDriver.download(buildDownloadTargetOptions(options, classified.url));
+    }
+    if (this.browserDriver) {
+      try {
+        return await this.browserDriver.download(buildDownloadTargetOptions(options, classified.url));
+      } catch (error) {
+        if (error instanceof VideoCommandError && error.code === "VIDEO_BROWSER_UNAVAILABLE") {
+        } else if (!isBrowserDownloadTimeout(error)) {
+          throw error;
+        }
+      }
+    }
+    if (classified.kind === "mp4") {
+      return this.directDriver.download(buildDownloadTargetOptions(options, classified.url));
+    }
+    const sniffed = await this.sniffService.sniff({
+      mode: options.mode,
+      sourceUrl: classified.url,
+      ...buildProxyOptions2(options)
+    });
+    const candidate = sniffed.candidates[0];
+    if (!candidate) {
+      throw new VideoCommandError(
+        "VIDEO_NO_CANDIDATE",
+        "No supported media candidate was detected for the provided input."
+      );
+    }
+    if (candidate.type === "mp4") {
+      return this.directDriver.download(buildDownloadTargetOptions(options, candidate.url));
+    }
+    return this.hlsDriver.download(buildDownloadTargetOptions(options, candidate.url));
+  }
+};
+function isBrowserDownloadTimeout(error) {
+  return error instanceof Error && error.message.includes('waiting for event "download"');
+}
+function buildProxyOptions2(options) {
+  return {
+    ...options.noProxy === void 0 ? {} : { noProxy: options.noProxy },
+    ...options.proxyUrl === void 0 ? {} : { proxyUrl: options.proxyUrl }
+  };
+}
+function buildDownloadTargetOptions(options, sourceUrl) {
+  return {
+    ...optional("outputDir", options.outputDir),
+    ...optional("outputPath", options.outputPath),
+    ...optional("noProxy", options.noProxy),
+    ...optional("proxyUrl", options.proxyUrl),
+    sourceUrl
+  };
+}
+
+// src/video/compress/service.ts
+import { extname as extname2 } from "path";
+
+// src/video/compress/preset.ts
+var VIDEO_COMPRESSION_DEFAULTS = {
+  audioBitrate: "64k",
+  audioCodec: "aac",
+  container: "mp4",
+  videoCodec: "libx265"
+};
+
+// src/video/compress/ffmpeg.ts
+function buildFfmpegArgs(options) {
+  const args = [
+    "-i",
+    options.inputPath,
+    "-c:v",
+    VIDEO_COMPRESSION_DEFAULTS.videoCodec
+  ];
+  if (options.videoBitrate) {
+    args.push("-b:v", options.videoBitrate);
+  }
+  if (options.resolution) {
+    const [width, height] = options.resolution.split("x");
+    args.push("-vf", `scale=${width}:${height}`);
+  }
+  args.push(
+    "-c:a",
+    VIDEO_COMPRESSION_DEFAULTS.audioCodec,
+    "-b:a",
+    options.audioBitrate ?? VIDEO_COMPRESSION_DEFAULTS.audioBitrate,
+    options.outputPath
+  );
+  return args;
+}
+function probeFfmpegResult(result) {
+  return result.code === 0 && result.stdout.includes("ffmpeg version");
+}
+
+// src/video/compress/service.ts
+var VideoCompressionService = class {
+  runtime;
+  constructor(dependencies) {
+    this.runtime = dependencies.runtime;
+  }
+  async compress(options) {
+    const probe = await this.runtime.execFile("ffmpeg", ["-version"]);
+    if (!probeFfmpegResult(probe)) {
+      throw new VideoCommandError(
+        "VIDEO_FFMPEG_MISSING",
+        "ffmpeg is required for video compression."
+      );
+    }
+    const outputPath = options.outputPath ?? replaceExtension(options.inputPath, ".mp4");
+    const execResult = await this.runtime.execFile(
+      "ffmpeg",
+      buildFfmpegArgs({
+        inputPath: options.inputPath,
+        outputPath,
+        ...options.audioBitrate ? { audioBitrate: options.audioBitrate } : {},
+        ...options.resolution ? { resolution: options.resolution } : {},
+        ...options.videoBitrate ? { videoBitrate: options.videoBitrate } : {}
+      })
+    );
+    if (execResult.code !== 0) {
+      throw new VideoCommandError(
+        "VIDEO_COMPRESSION_FAILED",
+        execResult.stderr || "Video compression failed."
+      );
+    }
+    return {
+      audioBitrate: options.audioBitrate ?? VIDEO_COMPRESSION_DEFAULTS.audioBitrate,
+      audioCodec: VIDEO_COMPRESSION_DEFAULTS.audioCodec,
+      codec: VIDEO_COMPRESSION_DEFAULTS.videoCodec,
+      inputPath: options.inputPath,
+      outputPath,
+      ...options.resolution ? { resolution: options.resolution } : {},
+      ...options.videoBitrate ? { videoBitrate: options.videoBitrate } : {}
+    };
+  }
+};
+function replaceExtension(path, nextExtension) {
+  const currentExtension = extname2(path);
+  return currentExtension.length === 0 ? `${path}${nextExtension}` : `${path.slice(0, -currentExtension.length)}${nextExtension}`;
+}
+
+// src/video/output.ts
+import { table as table3 } from "table";
+function renderVideoCandidatesAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result,
+      meta: {
+        count: result.candidates.length
+      }
+    },
+    null,
+    2
+  );
+}
+function renderVideoDownloadResultAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderVideoCompressionResultAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderVideoCommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+function renderVideoCandidatesAsTable(result) {
+  return renderVideoOperationAsTable([
+    ["type", "url", "origin", "mode"],
+    ...result.candidates.map((candidate) => [
+      candidate.type,
+      candidate.url,
+      candidate.origin,
+      result.mode
+    ])
+  ]);
+}
+function renderVideoOperationAsTable(rows) {
+  return table3(rows);
+}
+
+// src/video/command.ts
+var sniffOptionsSchema = z4.object({
+  format: z4.enum(["json", "table"]).default("json"),
+  mode: z4.enum(["auto", "browser", "http"]).default("auto"),
+  proxy: z4.string().optional(),
+  skipProxy: z4.boolean().default(false)
+});
+var downloadOptionsSchema = z4.object({
+  format: z4.enum(["json", "table"]).default("json"),
+  mode: z4.enum(["auto", "browser", "http"]).default("auto"),
+  outputDir: z4.string().optional(),
+  proxy: z4.string().optional(),
+  skipProxy: z4.boolean().default(false)
+});
+var compressOptionsSchema = z4.object({
+  audioBitrate: z4.string().optional(),
+  format: z4.enum(["json", "table"]).default("json"),
+  outputPath: z4.string().optional(),
+  resolution: z4.string().optional(),
+  videoBitrate: z4.string().optional()
+});
+function registerVideoCommands(program, dependencies) {
+  const video = program.command("video").description("Inspect, download, and compress video media.");
+  const browserProvider = new BrowserVideoSniffProvider({
+    runtime: dependencies.runtime
+  });
+  const httpProvider = new HttpVideoSniffProvider({
+    runtime: dependencies.runtime
+  });
+  const sniffService = new VideoSniffService({
+    browserProvider: (sourceUrl, opts) => browserProvider.sniff(sourceUrl, opts),
+    httpProvider: (sourceUrl, opts) => httpProvider.sniff(sourceUrl, opts)
+  });
+  const browserDriver = new BrowserDownloadDriver();
+  const downloadService = new VideoDownloadService({
+    directDriver: new DirectVideoDownloadDriver({
+      runtime: dependencies.runtime
+    }),
+    hlsDriver: new HlsVideoDownloadDriver({
+      runtime: dependencies.runtime
+    }),
+    sniffService,
+    browserDriver
+  });
+  const compressionService = new VideoCompressionService({
+    runtime: dependencies.runtime
+  });
+  video.command("sniff").argument("<input>", "page url or media url").option("--mode <mode>", "sniff mode", "auto").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").option("--proxy <proxy>", "proxy URL").option("--skip-proxy", "disable proxy").action(async (input2, options) => {
+    const parsed = sniffOptionsSchema.parse(applyVideoTableShortcut(options));
+    const result = await sniffService.sniff({
+      mode: parsed.mode,
+      sourceUrl: input2,
+      ...parsed.proxy ? { proxyUrl: parsed.proxy } : {},
+      ...parsed.skipProxy ? { noProxy: true } : {}
+    });
+    if (parsed.format === "table") {
+      dependencies.stdout(`${renderVideoCandidatesAsTable(result)}
+`);
+      return;
+    }
+    dependencies.stdout(`${renderVideoCandidatesAsJson(result)}
+`);
+  });
+  video.command("download").argument("<input>", "page url, m3u8 url, or mp4 url").option("--mode <mode>", "sniff mode", "auto").option("--output-dir <outputDir>", "output directory").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").option("--proxy <proxy>", "proxy URL").option("--skip-proxy", "disable proxy").action(async (input2, options) => {
+    const parsed = downloadOptionsSchema.parse(applyVideoTableShortcut(options));
+    const result = await downloadService.download({
+      input: input2,
+      mode: parsed.mode,
+      ...parsed.outputDir ? { outputDir: parsed.outputDir } : {},
+      ...parsed.proxy ? { proxyUrl: parsed.proxy } : {},
+      ...parsed.skipProxy ? { noProxy: true } : {}
+    });
+    if (parsed.format === "table") {
+      dependencies.stdout(
+        `${renderVideoOperationAsTable([
+          ["field", "value"],
+          ["mediaType", result.mediaType],
+          ["outputPath", result.outputPath]
+        ])}
+`
+      );
+      return;
+    }
+    dependencies.stdout(`${renderVideoDownloadResultAsJson(result)}
+`);
+  });
+  video.command("compress").argument("<input>", "local input video path").option("--output-path <outputPath>", "output path").option("--resolution <resolution>", "target resolution, such as 1280x720").option("--video-bitrate <videoBitrate>", "target video bitrate").option("--audio-bitrate <audioBitrate>", "target audio bitrate").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (input2, options) => {
+    const parsed = compressOptionsSchema.parse(applyVideoTableShortcut(options));
+    const result = await compressionService.compress({
+      inputPath: input2,
+      ...parsed.audioBitrate ? { audioBitrate: parsed.audioBitrate } : {},
+      ...parsed.outputPath ? { outputPath: parsed.outputPath } : {},
+      ...parsed.resolution ? { resolution: parsed.resolution } : {},
+      ...parsed.videoBitrate ? { videoBitrate: parsed.videoBitrate } : {}
+    });
+    if (parsed.format === "table") {
+      dependencies.stdout(
+        `${renderVideoOperationAsTable([
+          ["field", "value"],
+          ["codec", result.codec],
+          ["outputPath", result.outputPath]
+        ])}
+`
+      );
+      return;
+    }
+    dependencies.stdout(`${renderVideoCompressionResultAsJson(result)}
+`);
+  });
+}
+function handleVideoCommandError(error, dependencies) {
+  if (error instanceof VideoCommandError) {
+    const details = error.details;
+    dependencies.stderr(
+      `${renderVideoCommandErrorAsJson(
+        error.code,
+        error.message,
+        details
+      )}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function applyVideoTableShortcut(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  if (options.format) {
+    return {
+      ...options,
+      format: options.format
+    };
+  }
+  throw new Error("Output format is required for this command.");
+}
+
+// src/36kr/command.ts
+import { z as z5 } from "zod";
+
+// src/36kr/output.ts
+import { table as table4 } from "table";
+function renderKr36ArticleAsJson(article) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: article
+    },
+    null,
+    2
+  );
+}
+function renderKr36InformationListAsJson(list) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: list
+    },
+    null,
+    2
+  );
+}
+function renderKr36InformationListAsTable(list) {
+  return table4([
+    ["id", "title", "author", "publishTime", "url"],
+    ...list.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderKr36CommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/36kr/types.ts
+var Kr36CommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "Kr36CommandError";
+  }
+};
+
+// src/36kr/service.ts
+var KR36_BROWSER_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+  "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+  "Cache-Control": "no-cache",
+  Pragma: "no-cache",
+  Referer: "https://36kr.com/",
+  "Sec-Fetch-Dest": "document",
+  "Sec-Fetch-Mode": "navigate",
+  "Sec-Fetch-Site": "same-origin",
+  "Sec-Fetch-User": "?1",
+  "Upgrade-Insecure-Requests": "1",
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+};
+var KR36_INFORMATION_ENDPOINT = "https://gateway.36kr.com/api/mis/nav/ifm/subNav/flow";
+var KR36_INFORMATION_PAGE_SIZE = 30;
+var KR36_SUPPORTED_CHANNELS = /* @__PURE__ */ new Set(["AI", "technology"]);
+var KR36_JSON_HEADERS = {
+  Accept: "application/json, text/plain, */*",
+  "Accept-Language": KR36_BROWSER_HEADERS["Accept-Language"],
+  "Content-Type": "application/json;charset=UTF-8",
+  Origin: "https://36kr.com",
+  "User-Agent": KR36_BROWSER_HEADERS["User-Agent"]
+};
+var Kr36ArticleService = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  async getArticle(articleId) {
+    assertArticleId(articleId);
+    const request = buildKr36ArticleRequest(articleId);
+    const html = await this.runtime.fetchArticleHtml(request);
+    const initialState = parseInitialState(html);
+    const articleDetail = initialState.articleDetail;
+    const rawArticle = articleDetail?.articleDetailData?.data;
+    if (!rawArticle) {
+      throw new Kr36CommandError(
+        "KR36_PARSE_ERROR",
+        "36kr article data was not found in window.initialState.",
+        2
+      );
+    }
+    const contentHtml = rawArticle.widgetContent ?? "";
+    const recommend = articleDetail?.articleRecommendData ?? {};
+    const publishTime = rawArticle.publishTime ?? 0;
+    const article = {
+      author: buildAuthor(rawArticle, recommend),
+      content: {
+        html: contentHtml,
+        paragraphs: extractParagraphs(contentHtml)
+      },
+      id: String(rawArticle.itemId ?? articleId),
+      imageSources: rawArticle.imgSources ?? [],
+      images: extractImages(contentHtml),
+      latestArticles: (articleDetail?.latestArticle?.articleLatestList ?? []).map((item) => ({
+        id: item.id,
+        title: item.title
+      })),
+      newestArticles: (recommend.newestItemList ?? []).map((item) => {
+        const listItem = {
+          id: item.itemId,
+          title: item.itemTitle
+        };
+        if (item.itemContent !== void 0) {
+          listItem.content = item.itemContent;
+        }
+        if (item.publishTime !== void 0) {
+          listItem.publishTime = item.publishTime;
+        }
+        if (item.itemRoute !== void 0) {
+          listItem.route = item.itemRoute;
+        }
+        return listItem;
+      }),
+      organizations: articleDetail?.organArticleData?.data?.organizationList ?? [],
+      publishTime: {
+        iso: publishTime ? new Date(publishTime).toISOString() : "",
+        local: publishTime ? formatChinaTime(publishTime) : "",
+        ms: publishTime
+      },
+      relatedArticles: (recommend.relateArticleList ?? []).map((item) => {
+        const listItem = {
+          id: item.itemId,
+          title: item.widgetTitle
+        };
+        const author = item.author ?? item.authorName;
+        if (author !== void 0) {
+          listItem.author = author;
+        }
+        if (item.widgetImage !== void 0) {
+          listItem.image = item.widgetImage;
+        }
+        if (item.route !== void 0) {
+          listItem.route = item.route;
+        }
+        return listItem;
+      }),
+      request,
+      stats: buildStats(articleDetail?.likeCount, articleDetail?.favoriteCount, recommend),
+      summary: rawArticle.summary ?? "",
+      title: rawArticle.widgetTitle ?? "",
+      url: request.url
+    };
+    if (rawArticle.companyCertifyNick !== void 0) {
+      article.companyCertifyNick = rawArticle.companyCertifyNick;
+    }
+    if (rawArticle.popinImage !== void 0) {
+      article.coverImage = rawArticle.popinImage;
+    }
+    if (recommend.nextItem) {
+      article.nextArticle = {
+        id: recommend.nextItem.itemId,
+        title: recommend.nextItem.itemTitle
+      };
+      if (recommend.nextItem.itemContent !== void 0) {
+        article.nextArticle.content = recommend.nextItem.itemContent;
+      }
+      if (recommend.nextItem.publishTime !== void 0) {
+        article.nextArticle.publishTime = recommend.nextItem.publishTime;
+      }
+      if (recommend.nextItem.itemRoute !== void 0) {
+        article.nextArticle.route = recommend.nextItem.itemRoute;
+      }
+    }
+    if (rawArticle.sourceType !== void 0) {
+      article.sourceType = rawArticle.sourceType;
+    }
+    return article;
+  }
+  async getInformationList(options) {
+    const channel = parseInformationChannel(options.channel);
+    const pageLimit = normalizePages(options.pages);
+    const firstPageRequest = buildKr36InformationFirstPageRequest(channel);
+    const firstPageHtml = await this.runtime.fetchArticleHtml(firstPageRequest);
+    const firstPageState = parseInitialState(firstPageHtml);
+    const firstPageList = firstPageState.information?.informationList;
+    if (!firstPageList) {
+      throw new Kr36CommandError(
+        "KR36_PARSE_ERROR",
+        "36kr information list data was not found in window.initialState.",
+        2
+      );
+    }
+    const items = [...mapInformationItems(firstPageList.itemList ?? [])];
+    let pageCallback = firstPageList.pageCallback ?? "";
+    let hasNextPage = firstPageList.hasNextPage ?? 0;
+    let fetchedPages = 1;
+    while (fetchedPages < pageLimit && hasNextPage && pageCallback) {
+      const request = buildKr36InformationNextPageRequest(channel, pageCallback);
+      const response = parseInformationFlowResponse(await this.runtime.fetchJson(request));
+      const nextList = response.data ?? {};
+      items.push(...mapInformationItems(nextList.itemList ?? []));
+      pageCallback = nextList.pageCallback ?? "";
+      hasNextPage = nextList.hasNextPage ?? 0;
+      fetchedPages += 1;
+    }
+    return {
+      channel,
+      items,
+      meta: {
+        fetchedPages,
+        hasNextPage,
+        nextPageCallback: pageCallback,
+        pageSize: KR36_INFORMATION_PAGE_SIZE,
+        totalItems: items.length
+      },
+      request: {
+        firstPage: firstPageRequest,
+        nextPageEndpoint: KR36_INFORMATION_ENDPOINT
+      }
+    };
+  }
+};
+function buildKr36ArticleUrl(articleId) {
+  assertArticleId(articleId);
+  return `https://36kr.com/p/${articleId}?f=rss`;
+}
+function buildKr36ArticleRequest(articleId) {
+  return {
+    headers: KR36_BROWSER_HEADERS,
+    url: buildKr36ArticleUrl(articleId)
+  };
+}
+function buildKr36InformationFirstPageRequest(channel) {
+  return {
+    headers: KR36_BROWSER_HEADERS,
+    url: `https://36kr.com/information/${channel}/`
+  };
+}
+function buildKr36InformationNextPageRequest(channel, pageCallback, timestamp = Date.now()) {
+  return {
+    body: {
+      partner_id: "web",
+      timestamp,
+      param: {
+        subnavType: 1,
+        subnavNick: channel,
+        pageSize: KR36_INFORMATION_PAGE_SIZE,
+        pageEvent: 1,
+        pageCallback,
+        siteId: 1,
+        platformId: 2
+      }
+    },
+    headers: {
+      ...KR36_JSON_HEADERS,
+      Referer: `https://36kr.com/information/${channel}/`
+    },
+    url: KR36_INFORMATION_ENDPOINT
+  };
+}
+function assertArticleId(articleId) {
+  if (!/^\d+$/.test(articleId)) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_ARTICLE_ID",
+      "36kr article id must contain digits only.",
+      2,
+      {
+        articleId
+      }
+    );
+  }
+}
+function parseInformationChannel(channel) {
+  if (KR36_SUPPORTED_CHANNELS.has(channel)) {
+    return channel;
+  }
+  throw new Kr36CommandError(
+    "KR36_INVALID_CHANNEL",
+    "36kr list only supports AI and technology channels.",
+    2,
+    {
+      channel,
+      supportedChannels: [...KR36_SUPPORTED_CHANNELS]
+    }
+  );
+}
+function normalizePages(pages) {
+  const value = pages ?? 1;
+  if (!Number.isInteger(value) || value < 1 || value > 20) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_PAGES",
+      "36kr list pages must be an integer between 1 and 20.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return value;
+}
+function parseInitialState(html) {
+  const match = /window\.initialState=(\{[\s\S]*?\})\s*;?\s*<\/script>/.exec(html);
+  if (!match?.[1]) {
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "window.initialState was not found in the 36kr article page.",
+      2
+    );
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch (error) {
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "Failed to parse window.initialState from the 36kr article page.",
+      2,
+      {
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+function extractImages(html) {
+  return [...html.matchAll(/<img\b[^>]*>/gi)].map((match, index) => {
+    const tag = match[0];
+    return {
+      index: index + 1,
+      size: getAttribute(tag, "data-img-size-val"),
+      url: getAttribute(tag, "src") ?? ""
+    };
+  }).filter((image) => image.url);
+}
+function parseInformationFlowResponse(jsonText) {
+  try {
+    const response = JSON.parse(jsonText);
+    if (response.code !== 0) {
+      throw new Kr36CommandError(
+        "KR36_REQUEST_FAILED",
+        response.msg || "36kr information flow request failed.",
+        1,
+        {
+          code: response.code
+        }
+      );
+    }
+    return response;
+  } catch (error) {
+    if (error instanceof Kr36CommandError) {
+      throw error;
+    }
+    throw new Kr36CommandError(
+      "KR36_PARSE_ERROR",
+      "Failed to parse 36kr information flow response.",
+      2,
+      {
+        cause: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+function mapInformationItems(items) {
+  return items.map((item) => {
+    const material = item.templateMaterial ?? {};
+    const mapped = {
+      id: item.itemId,
+      title: material.widgetTitle ?? "",
+      url: `https://36kr.com/p/${item.itemId}`
+    };
+    if (material.authorName !== void 0) {
+      mapped.authorName = material.authorName;
+    }
+    if (material.authorRoute !== void 0) {
+      mapped.authorRoute = material.authorRoute;
+    }
+    if (material.widgetImage !== void 0) {
+      mapped.image = material.widgetImage;
+    }
+    if (material.publishTime !== void 0) {
+      mapped.publishTime = {
+        iso: new Date(material.publishTime).toISOString(),
+        local: formatChinaTime(material.publishTime),
+        ms: material.publishTime
+      };
+    }
+    if (item.route !== void 0) {
+      mapped.route = item.route;
+    }
+    if (material.summary !== void 0) {
+      mapped.summary = material.summary;
+    }
+    return mapped;
+  });
+}
+function extractParagraphs(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "\n").split(/\n+/).map((value) => decodeHtmlEntities(value).trim()).filter(Boolean);
+}
+function getAttribute(tag, name) {
+  const match = new RegExp(`${name}=["']([^"']+)["']`, "i").exec(tag);
+  return match?.[1] ?? null;
+}
+function decodeHtmlEntities(value) {
+  return value.replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function buildStats(likeCount, favoriteCount, recommend) {
+  return {
+    authorArticleCount: recommend.statArticle ?? 0,
+    collect: recommend.statCollect ?? 0,
+    comment: recommend.statComment ?? 0,
+    favoriteCount: favoriteCount ?? 0,
+    likeCount: likeCount ?? 0,
+    praise: recommend.statPraise ?? 0
+  };
+}
+function buildAuthor(rawArticle, recommend) {
+  const author = {
+    name: rawArticle.author ?? recommend.authorName ?? ""
+  };
+  const face = rawArticle.authorFace ?? recommend.authorFace;
+  if (face !== void 0) {
+    author.face = face;
+  }
+  if (rawArticle.authorId !== void 0) {
+    author.id = rawArticle.authorId;
+  }
+  if (rawArticle.authorRoute !== void 0) {
+    author.route = rawArticle.authorRoute;
+  }
+  if (recommend.authorSummary !== void 0) {
+    author.summary = recommend.authorSummary;
+  }
+  if (recommend.authorTitle !== void 0) {
+    author.title = recommend.authorTitle;
+  }
+  return author;
+}
+function formatChinaTime(timestampMs) {
+  const formatter = new Intl.DateTimeFormat("sv-SE", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    second: "2-digit",
+    timeZone: "Asia/Shanghai",
+    year: "numeric"
+  });
+  return formatter.format(new Date(timestampMs));
+}
+
+// src/36kr/command.ts
+var articleOptionsSchema = z5.object({
+  format: z5.enum(["json"]).default("json")
+});
+var informationListOptionsSchema = z5.object({
+  format: z5.enum(["json", "table"]).default("json"),
+  pages: z5.number().int().min(1).max(20).default(1),
+  table: z5.boolean().optional()
+});
+function registerKr36Commands(program, dependencies) {
+  const kr36 = program.command("36kr").description("Fetch and parse 36kr content.");
+  const articleService = new Kr36ArticleService(dependencies.runtime);
+  kr36.command("article").argument("<articleId>", "36kr article id").option("--format <format>", "output format", "json").action(async (articleId, options) => {
+    articleOptionsSchema.parse(options);
+    const article = await articleService.getArticle(articleId);
+    dependencies.stdout(`${renderKr36ArticleAsJson(article)}
+`);
+  });
+  kr36.command("list").argument("<channel>", "36kr information channel: AI or technology").option("--pages <pages>", "number of pages to fetch", parsePages, 1).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (channel, options) => {
+    const parsed = informationListOptionsSchema.parse(applyTableShortcut(options));
+    const list = await articleService.getInformationList({
+      channel,
+      pages: parsed.pages
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderKr36InformationListAsTable(list)}
+` : `${renderKr36InformationListAsJson(list)}
+`
+    );
+  });
+}
+function handleKr36CommandError(error, dependencies) {
+  if (error instanceof Kr36CommandError) {
+    dependencies.stderr(
+      `${renderKr36CommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parsePages(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new Kr36CommandError(
+      "KR36_INVALID_PAGES",
+      "36kr list pages must be an integer between 1 and 20.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format ?? "json"
+  };
+}
+
+// src/toutiao/command.ts
+import { z as z6 } from "zod";
+
+// src/toutiao/output.ts
+import { table as table5 } from "table";
+function renderToutiaoListAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoListAsTable(result) {
+  return table5([
+    ["id", "title", "author", "publishTime", "comments", "url"],
+    ...result.items.map((item) => [
+      item.id,
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.url
+    ])
+  ]);
+}
+function renderToutiaoArticleAsJson(article) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: article
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoAuthorAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderToutiaoAuthorAsTable(result) {
+  return table5([
+    ["id", "title", "author", "publishTime", "comments", "url"],
+    ...result.items.map((item) => [
+      item.id,
+      item.title,
+      item.authorName ?? "",
+      item.publishTime?.local ?? "",
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.url
+    ])
+  ]);
+}
+function renderToutiaoCommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/toutiao/types.ts
+var ToutiaoCommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "ToutiaoCommandError";
+  }
+};
+
+// src/toutiao/service.ts
+var SUPPORTED_SOURCES = /* @__PURE__ */ new Set(["tech", "AI", "\u5149\u523B\u673A", "\u82AF\u7247", "\u534A\u5BFC\u4F53"]);
+var ToutiaoService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async article(input2) {
+    const url = buildToutiaoArticleUrl(input2);
+    return this.dependencies.runtime.fetchArticle({
+      input: input2,
+      url
+    });
+  }
+  async author(input2, options = {}) {
+    const authorToken = buildToutiaoAuthorToken(input2);
+    const pages = normalizePages2(options.pages);
+    const url = buildToutiaoAuthorUrl(authorToken);
+    const runtimeResult = await this.dependencies.runtime.fetchAuthorArticles({
+      authorToken,
+      pages,
+      url
+    });
+    const withContent = options.withContent ?? false;
+    const result = {
+      ...runtimeResult,
+      meta: {
+        fetchedPages: pages,
+        totalItems: runtimeResult.items.length,
+        withContent
+      },
+      request: {
+        input: input2,
+        url
+      }
+    };
+    if (withContent) {
+      const articles = [];
+      for (const item of runtimeResult.items) {
+        articles.push(await this.dependencies.runtime.fetchArticle({
+          input: item.id,
+          url: buildToutiaoArticleUrl(item.url || item.id)
+        }));
+      }
+      result.articles = articles;
+      result.meta.totalArticles = articles.length;
+    }
+    return result;
+  }
+  async list(options) {
+    const source = parseSource(options.source);
+    const pages = normalizePages2(options.pages);
+    const runtimeResult = source === "tech" ? await this.dependencies.runtime.fetchTechnologyChannel({ pages }) : await this.dependencies.runtime.fetchKeywordInformation({
+      keyword: source,
+      pages,
+      source
+    });
+    return {
+      ...runtimeResult,
+      meta: {
+        fetchedPages: pages,
+        totalItems: runtimeResult.items.length
+      }
+    };
+  }
+};
+function buildToutiaoAuthorToken(input2) {
+  const trimmed = input2.trim();
+  if (/^[A-Za-z0-9._-]+$/.test(trimmed) && trimmed.length >= 12) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    const token = /\/c\/user\/token\/([^/?#]+)/.exec(url.pathname)?.[1];
+    if (token && isToutiaoHost(url.hostname)) {
+      return decodeURIComponent(token);
+    }
+  } catch {
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_AUTHOR",
+    "Toutiao author must be a user token or a /c/user/token/<token>/ homepage URL.",
+    2,
+    {
+      input: input2
+    }
+  );
+}
+function buildToutiaoAuthorUrl(authorToken) {
+  return `https://www.toutiao.com/c/user/token/${encodeURIComponent(authorToken)}/`;
+}
+function buildToutiaoArticleUrl(input2) {
+  const trimmed = input2.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return `https://www.toutiao.com/article/${trimmed}/`;
+  }
+  try {
+    const url = new URL(trimmed);
+    const id = /(?:article|group)\/(\d+)/.exec(url.pathname)?.[1] ?? /^\/a(\d+)/.exec(url.pathname)?.[1];
+    if (id && isToutiaoHost(url.hostname)) {
+      return `https://www.toutiao.com/article/${id}/`;
+    }
+    const nextUrl = url.searchParams.get("url");
+    if (nextUrl) {
+      return buildToutiaoArticleUrl(nextUrl);
+    }
+  } catch {
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_ARTICLE",
+    "Toutiao article must be a numeric id or a toutiao article/group URL.",
+    2,
+    {
+      input: input2
+    }
+  );
+}
+function isToutiaoHost(hostname) {
+  return hostname === "www.toutiao.com" || hostname === "toutiao.com";
+}
+function parseSource(source) {
+  if (SUPPORTED_SOURCES.has(source)) {
+    return source;
+  }
+  throw new ToutiaoCommandError(
+    "TOUTIAO_INVALID_SOURCE",
+    "Toutiao list only supports tech, AI, \u5149\u523B\u673A, \u82AF\u7247, and \u534A\u5BFC\u4F53.",
+    2,
+    {
+      source,
+      supportedSources: [...SUPPORTED_SOURCES]
+    }
+  );
+}
+function normalizePages2(pages) {
+  const value = pages ?? 1;
+  if (!Number.isInteger(value) || value < 1 || value > 5) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_INVALID_PAGES",
+      "Toutiao list pages must be an integer between 1 and 5.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return value;
+}
+
+// src/toutiao/command.ts
+var listOptionsSchema = z6.object({
+  format: z6.enum(["json", "table"]).default("json"),
+  pages: z6.number().int().min(1).max(5).default(1),
+  table: z6.boolean().optional()
+});
+var articleOptionsSchema2 = z6.object({
+  format: z6.enum(["json"]).default("json")
+});
+var authorOptionsSchema = z6.object({
+  format: z6.enum(["json", "table"]).default("json"),
+  pages: z6.number().int().min(1).max(5).default(1),
+  table: z6.boolean().optional(),
+  withContent: z6.boolean().default(false)
+});
+function registerToutiaoCommands(program, dependencies) {
+  const toutiao = program.command("toutiao").description("Fetch Toutiao channel and search content.");
+  const service = new ToutiaoService({ runtime: dependencies.runtime });
+  toutiao.command("article").argument("<article>", "Toutiao article id or URL").option("--format <format>", "output format", "json").action(async (article, options) => {
+    articleOptionsSchema2.parse(options);
+    const result = await service.article(article);
+    dependencies.stdout(`${renderToutiaoArticleAsJson(result)}
+`);
+  });
+  toutiao.command("list").argument("<source>", "Toutiao source: tech, AI, \u5149\u523B\u673A, \u82AF\u7247, or \u534A\u5BFC\u4F53").option("--pages <pages>", "number of pages to fetch", parsePages2, 1).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (source, options) => {
+    const parsed = listOptionsSchema.parse(applyTableShortcut2(options));
+    const result = await service.list({
+      pages: parsed.pages,
+      source
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderToutiaoListAsTable(result)}
+` : `${renderToutiaoListAsJson(result)}
+`
+    );
+  });
+  toutiao.command("author").argument("<author>", "Toutiao author token or /c/user/token/<token>/ homepage URL").option("--pages <pages>", "number of pages to fetch", parsePages2, 1).option("--with-content", "also fetch detail content for each author article").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (author, options) => {
+    const parsed = authorOptionsSchema.parse(applyTableShortcut2(options));
+    const result = await service.author(author, {
+      pages: parsed.pages,
+      withContent: parsed.withContent
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderToutiaoAuthorAsTable(result)}
+` : `${renderToutiaoAuthorAsJson(result)}
+`
+    );
+  });
+}
+function handleToutiaoCommandError(error, dependencies) {
+  if (error instanceof ToutiaoCommandError) {
+    dependencies.stderr(
+      `${renderToutiaoCommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parsePages2(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_INVALID_PAGES",
+      "Toutiao list pages must be an integer between 1 and 5.",
+      2,
+      {
+        pages: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut2(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format ?? "json"
+  };
+}
+
+// src/hn/command.ts
+import { z as z7 } from "zod";
+
+// src/hn/output.ts
+import { table as table6 } from "table";
+function renderHackerNewsStoriesAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderHackerNewsStoriesAsTable(result) {
+  return table6([
+    ["id", "title", "author", "score", "comments", "time", "url"],
+    ...result.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.author ?? "",
+      item.score === void 0 ? "" : String(item.score),
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.time?.iso ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderHackerNewsSearchAsJson(result) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: result
+    },
+    null,
+    2
+  );
+}
+function renderHackerNewsSearchAsTable(result) {
+  return table6([
+    ["id", "title", "author", "score", "comments", "time", "url"],
+    ...result.items.map((item) => [
+      String(item.id),
+      item.title,
+      item.author ?? "",
+      item.score === void 0 ? "" : String(item.score),
+      item.commentCount === void 0 ? "" : String(item.commentCount),
+      item.time?.iso ?? "",
+      item.url
+    ])
+  ]);
+}
+function renderHackerNewsCommandErrorAsJson(code, message, details) {
+  return JSON.stringify(
+    {
+      ok: false,
+      error: {
+        code,
+        message,
+        ...details === void 0 ? {} : { details }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/hn/types.ts
+var HackerNewsCommandError = class extends Error {
+  constructor(code, message, exitCode, details) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+    this.name = "HackerNewsCommandError";
+  }
+};
+
+// src/hn/service.ts
+var SUPPORTED_SOURCES2 = /* @__PURE__ */ new Set(["top", "new", "best"]);
+var HackerNewsService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async stories(options) {
+    const source = parseSource2(options.source);
+    const limit = normalizeLimit(options.limit);
+    const runtimeResult = await this.dependencies.runtime.fetchStories({
+      limit,
+      source
+    });
+    return {
+      ...runtimeResult,
+      meta: {
+        limit,
+        totalItems: runtimeResult.items.length
+      }
+    };
+  }
+  async search(options) {
+    const query = normalizeQuery(options.query);
+    const limit = normalizeLimit(options.limit);
+    const sort = options.sort ?? "relevance";
+    const runtimeResult = await this.dependencies.runtime.fetchSearch({
+      limit,
+      query,
+      sort
+    });
+    return {
+      ...runtimeResult,
+      meta: {
+        limit,
+        sort,
+        totalItems: runtimeResult.items.length
+      }
+    };
+  }
+};
+function parseSource2(source) {
+  if (SUPPORTED_SOURCES2.has(source)) {
+    return source;
+  }
+  throw new HackerNewsCommandError(
+    "HN_INVALID_SOURCE",
+    "Hacker News list only supports top, new, and best.",
+    2,
+    {
+      source,
+      supportedSources: [...SUPPORTED_SOURCES2]
+    }
+  );
+}
+function normalizeLimit(limit) {
+  const value = limit ?? 30;
+  if (!Number.isInteger(value) || value < 1 || value > 100) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_LIMIT",
+      "Hacker News limit must be an integer between 1 and 100.",
+      2,
+      {
+        limit: value
+      }
+    );
+  }
+  return value;
+}
+function normalizeQuery(query) {
+  const value = query.trim();
+  if (value.length === 0) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_QUERY",
+      "Hacker News search query must not be empty.",
+      2
+    );
+  }
+  return value;
+}
+
+// src/hn/command.ts
+var storiesOptionsSchema = z7.object({
+  format: z7.enum(["json", "table"]).default("json"),
+  limit: z7.number().int().default(30),
+  table: z7.boolean().optional()
+});
+var searchOptionsSchema = z7.object({
+  format: z7.enum(["json", "table"]).default("json"),
+  limit: z7.number().int().default(30),
+  sort: z7.enum(["relevance", "date"]).default("relevance"),
+  table: z7.boolean().optional()
+});
+function registerHackerNewsCommands(program, dependencies) {
+  const hn = program.command("hn").description("Fetch Hacker News stories and search results.");
+  const service = new HackerNewsService({ runtime: dependencies.runtime });
+  for (const source of ["top", "new", "best"]) {
+    hn.command(source).option("--limit <limit>", "number of stories to fetch", parseLimit, 30).option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (options) => {
+      const parsed = storiesOptionsSchema.parse(applyTableShortcut3(options));
+      const result = await service.stories({
+        limit: parsed.limit,
+        source
+      });
+      dependencies.stdout(
+        parsed.format === "table" ? `${renderHackerNewsStoriesAsTable(result)}
+` : `${renderHackerNewsStoriesAsJson(result)}
+`
+      );
+    });
+  }
+  hn.command("search").argument("<query>", "search query").option("--limit <limit>", "number of search results to fetch", parseLimit, 30).option("--sort <sort>", "search sort: relevance or date", "relevance").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (query, options) => {
+    const parsed = searchOptionsSchema.parse(applyTableShortcut3(options));
+    const result = await service.search({
+      limit: parsed.limit,
+      query,
+      sort: parsed.sort
+    });
+    dependencies.stdout(
+      parsed.format === "table" ? `${renderHackerNewsSearchAsTable(result)}
+` : `${renderHackerNewsSearchAsJson(result)}
+`
+    );
+  });
+}
+function handleHackerNewsCommandError(error, dependencies) {
+  if (error instanceof HackerNewsCommandError) {
+    dependencies.stderr(
+      `${renderHackerNewsCommandErrorAsJson(error.code, error.message, error.details)}
+`
+    );
+    return error.exitCode;
+  }
+  return void 0;
+}
+function parseLimit(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new HackerNewsCommandError(
+      "HN_INVALID_LIMIT",
+      "Hacker News limit must be an integer between 1 and 100.",
+      2,
+      {
+        limit: value
+      }
+    );
+  }
+  return parsed;
+}
+function applyTableShortcut3(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  return {
+    ...options,
+    format: options.format ?? "json"
+  };
+}
+
+// src/ak/command.ts
+var envSchema = z8.string().transform((value, context) => {
+  try {
+    return normalizeAkEnv(value);
+  } catch (error) {
+    context.addIssue({
+      code: "custom",
+      message: error.message
+    });
+    return z8.NEVER;
+  }
+});
+var envDescription = `environment (recommended: ${AK_RECOMMENDED_ENVS.join(", ")}; custom values allowed)`;
+var addOptionsSchema = z8.object({
+  email: z8.string().optional(),
+  env: envSchema,
+  key: z8.string(),
+  phone: z8.string().optional(),
+  rawKey: z8.boolean().optional(),
+  userId: z8.string().optional(),
+  userName: z8.string().optional()
+});
+var listOptionsSchema2 = z8.object({
+  env: envSchema.optional(),
+  field: z8.string().optional(),
+  format: z8.enum(["json", "table"]).default("json"),
+  limit: z8.number().int().positive().max(100).default(50),
+  query: z8.string().optional(),
+  rawKey: z8.boolean().optional()
+});
+var getOptionsSchema = z8.object({
+  env: envSchema.optional(),
+  format: z8.enum(["json", "table"]).default("json"),
+  id: z8.string().optional(),
+  key: z8.string().optional(),
+  rawKey: z8.boolean().optional()
+});
+var updateOptionsSchema = z8.object({
+  email: z8.string().optional(),
+  env: envSchema.optional(),
+  format: z8.enum(["json", "table"]).default("json"),
+  id: z8.string().optional(),
+  key: z8.string().optional(),
+  phone: z8.string().optional(),
+  rawKey: z8.boolean().optional(),
+  userId: z8.string().optional(),
+  userName: z8.string().optional()
+});
+var deleteOptionsSchema = z8.object({
+  env: envSchema.optional(),
+  format: z8.enum(["json", "table"]).default("json"),
+  id: z8.string().optional(),
+  key: z8.string().optional(),
+  yes: z8.boolean().default(false)
+});
+var configFormatSchema = z8.object({
+  format: z8.enum(["json", "table"]).default("json")
+});
+var configGetOptionsSchema = z8.object({
+  format: z8.enum(["json", "table"]).default("json"),
+  key: z8.string()
+});
+var configSetOptionsSchema = z8.object({
+  format: z8.enum(["json", "table"]).default("json"),
+  key: z8.string(),
+  value: z8.string()
+});
+function createAkCli(dependencies) {
+  const program = new Command();
+  const createService = () => new AkService({
+    masterKey: dependencies.masterKey,
+    now: dependencies.now,
+    repository: dependencies.getRepository()
+  });
+  const createDiskCleanupService = () => {
+    const roots = dependencies.resolveDiskCleanupRoots();
+    return new DiskCleanupService({
+      runtime: dependencies.diskRuntime,
+      systemRoot: roots.systemRoot,
+      userProfileRoot: roots.userProfileRoot
+    });
+  };
+  program.name("stephen").description("A personal TypeScript CLI for agent-friendly workflows.").showHelpAfterError().exitOverride();
+  program.configureOutput({
+    outputError: (value) => dependencies.stderr(value),
+    writeErr: (value) => dependencies.stderr(value),
+    writeOut: (value) => dependencies.stdout(value)
+  });
+  const ak = program.command("ak").description("Manage API key records.");
+  const config = program.command("config").description("Manage local CLI configuration.");
+  registerDiskCommands(program, {
+    createDiskCleanupService,
+    stdout: dependencies.stdout
+  });
+  registerVideoCommands(program, {
+    runtime: dependencies.videoRuntime,
+    stderr: dependencies.stderr,
+    stdout: dependencies.stdout
+  });
+  registerKr36Commands(program, {
+    runtime: dependencies.kr36Runtime,
+    stderr: dependencies.stderr,
+    stdout: dependencies.stdout
+  });
+  registerToutiaoCommands(program, {
+    runtime: dependencies.toutiaoRuntime,
+    stderr: dependencies.stderr,
+    stdout: dependencies.stdout
+  });
+  registerHackerNewsCommands(program, {
+    runtime: dependencies.hackerNewsRuntime,
+    stderr: dependencies.stderr,
+    stdout: dependencies.stdout
+  });
+  ak.command("add").requiredOption("-e, --env <env>", envDescription).requiredOption("-k, --key <key>", "api key").option("-u, --user-id <userId>", "user id").option("-n, --user-name <userName>", "user name").option("-m, --email <email>", "email").option("-p, --phone <phone>", "phone").option("--raw-key", "show the raw key in the output").action((options) => {
+    const parsed = addOptionsSchema.parse(options);
+    writeRecords([createService().add(parsed)], "json", parsed.rawKey ?? false, 50, dependencies);
+  });
+  ak.command("get").option("--id <id>", "record id").option("-e, --env <env>", envDescription).option("-k, --key <key>", "api key").option("--raw-key", "show the raw key in the output").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((options) => {
+    const parsed = getOptionsSchema.parse(applyTableShortcut4(options));
+    writeRecords(
+      [createService().get(parsed)],
+      parsed.format,
+      parsed.rawKey ?? false,
+      1,
+      dependencies
+    );
+  });
+  ak.command("list").option("-e, --env <env>", envDescription).option("-q, --query <query>", "fuzzy query").option("-f, --field <field>", "query fields").option("--limit <limit>", "result limit", parseLimit2, 50).option("--raw-key", "show the raw key in the output").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((options) => {
+    const parsed = listOptionsSchema2.parse(applyTableShortcut4(options));
+    writeRecords(
+      createService().list(parsed),
+      parsed.format,
+      parsed.rawKey ?? false,
+      parsed.limit,
+      dependencies
+    );
+  });
+  ak.command("update").option("--id <id>", "record id").option("-e, --env <env>", envDescription).option("-k, --key <key>", "api key").option("-u, --user-id <userId>", "user id").option("-n, --user-name <userName>", "user name").option("-m, --email <email>", "email").option("-p, --phone <phone>", "phone").option("--raw-key", "show the raw key in the output").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((options) => {
+    const parsed = updateOptionsSchema.parse(applyTableShortcut4(options));
+    writeRecords(
+      [createService().update(parsed)],
+      parsed.format,
+      parsed.rawKey ?? false,
+      1,
+      dependencies
+    );
+  });
+  ak.command("delete").option("--id <id>", "record id").option("-e, --env <env>", envDescription).option("-k, --key <key>", "api key").option("--yes", "skip confirmation").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action(async (options) => {
+    const parsed = deleteOptionsSchema.parse(applyTableShortcut4(options));
+    if (!parsed.yes) {
+      const confirmed = await dependencies.confirm("Delete the API key record?");
+      if (!confirmed) {
+        throw new AkServiceError("ABORTED", "Delete operation cancelled.", 2);
+      }
+    }
+    const service = createService();
+    const record = service.get(parsed);
+    const deleted = service.delete(parsed);
+    if (!deleted) {
+      throw new AkServiceError("STORAGE_ERROR", "Failed to delete the API key record.", 6);
+    }
+    writeRecords([record], parsed.format, false, 1, dependencies);
+  });
+  config.command("list").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((options) => {
+    const parsed = configFormatSchema.parse(applyTableShortcut4(options));
+    const entries = listConfigEntries({
+      configDir: dependencies.paths.config,
+      dataDir: dependencies.paths.data,
+      env: dependencies.env
+    });
+    writeConfigEntries(entries, parsed.format, dependencies);
+  });
+  config.command("get").argument("<key>", "config key").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((key, options) => {
+    const parsed = configGetOptionsSchema.parse({
+      ...applyTableShortcut4(options),
+      key
+    });
+    assertSupportedConfigKey(parsed.key);
+    const entry = getConfigEntry(parsed.key, {
+      configDir: dependencies.paths.config,
+      dataDir: dependencies.paths.data,
+      env: dependencies.env
+    });
+    writeConfigEntries([entry], parsed.format, dependencies);
+  });
+  config.command("set").argument("<key>", "config key").argument("<value>", "config value").option("--format <format>", "output format", "json").option("-t, --table", "render as a table").action((key, value, options) => {
+    const parsed = configSetOptionsSchema.parse({
+      ...applyTableShortcut4(options),
+      key,
+      value
+    });
+    assertSupportedConfigKey(parsed.key);
+    setConfigValue(parsed.key, parsed.value, {
+      configDir: dependencies.paths.config
+    });
+    const entry = getConfigEntry(parsed.key, {
+      configDir: dependencies.paths.config,
+      dataDir: dependencies.paths.data,
+      env: dependencies.env
+    });
+    writeConfigEntries([entry], parsed.format, dependencies);
+  });
+  return {
+    run: async (args) => {
+      try {
+        await program.parseAsync(["node", "stephen", ...args], {
+          from: "node"
+        });
+        return 0;
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "commander.helpDisplayed") {
+          return 0;
+        }
+        if (isCliError(error)) {
+          dependencies.stderr(
+            `${renderAkErrorAsJson(error.code, error.message, "details" in error ? error.details : void 0)}
+`
+          );
+          return error.exitCode;
+        }
+        const videoExitCode = handleVideoCommandError(error, {
+          stderr: dependencies.stderr
+        });
+        if (videoExitCode !== void 0) {
+          return videoExitCode;
+        }
+        const kr36ExitCode = handleKr36CommandError(error, {
+          stderr: dependencies.stderr
+        });
+        if (kr36ExitCode !== void 0) {
+          return kr36ExitCode;
+        }
+        const toutiaoExitCode = handleToutiaoCommandError(error, {
+          stderr: dependencies.stderr
+        });
+        if (toutiaoExitCode !== void 0) {
+          return toutiaoExitCode;
+        }
+        const hackerNewsExitCode = handleHackerNewsCommandError(error, {
+          stderr: dependencies.stderr
+        });
+        if (hackerNewsExitCode !== void 0) {
+          return hackerNewsExitCode;
+        }
+        if (error instanceof ZodError) {
+          dependencies.stderr(
+            `${renderAkErrorAsJson("INVALID_ARGUMENT", error.issues[0].message)}
+`
+          );
+          return 2;
+        }
+        if (error instanceof Error && "exitCode" in error && typeof error.exitCode === "number") {
+          return error.exitCode;
+        }
+        const message = error instanceof Error ? error.message : "Unexpected error.";
+        dependencies.stderr(`${renderAkErrorAsJson("UNEXPECTED_ERROR", message)}
+`);
+        return 1;
+      }
+    }
+  };
+}
+function isCliError(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" && "exitCode" in error && typeof error.exitCode === "number";
+}
+function parseLimit2(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid limit: '${value}' is not a number`);
+  }
+  return parsed;
+}
+function applyTableShortcut4(options) {
+  if (options.table) {
+    return {
+      ...options,
+      format: "table"
+    };
+  }
+  if (options.format) {
+    return {
+      ...options,
+      format: options.format
+    };
+  }
+  throw new Error("Output format is required for this command.");
+}
+function writeRecords(records, format, _rawKey, limit, dependencies) {
+  if (format === "table") {
+    dependencies.stdout(`${renderAkRecordsAsTable(records)}
+`);
+    return;
+  }
+  dependencies.stdout(`${renderAkRecordsAsJson(records, limit)}
+`);
+}
+function writeConfigEntries(entries, format, dependencies) {
+  if (format === "table") {
+    dependencies.stdout(`${renderConfigEntriesAsTable(entries)}
+`);
+    return;
+  }
+  dependencies.stdout(`${renderConfigEntriesAsJson(entries)}
+`);
+}
+function renderConfigEntriesAsJson(entries) {
+  return JSON.stringify(
+    {
+      ok: true,
+      data: entries,
+      meta: {
+        count: entries.length
+      }
+    },
+    null,
+    2
+  );
+}
+function renderConfigEntriesAsTable(entries) {
+  return table7([
+    ["key", "value", "source", "fileValue", "envValue", "defaultValue"],
+    ...entries.map((entry) => [
+      entry.key,
+      entry.value,
+      entry.source,
+      entry.fileValue ?? "",
+      entry.envValue ?? "",
+      entry.defaultValue
+    ])
+  ]);
+}
+
+// src/ak/database.ts
+import Database from "better-sqlite3";
+function createAkDatabase(filename = ":memory:") {
+  const database = new Database(filename);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS ak_records (
+      id TEXT PRIMARY KEY,
+      env TEXT NOT NULL,
+      user_id TEXT,
+      user_name TEXT,
+      email TEXT,
+      phone TEXT,
+      key_ciphertext TEXT NOT NULL,
+      key_search_prefix TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ak_env ON ak_records(env);
+    CREATE INDEX IF NOT EXISTS idx_ak_user_id ON ak_records(user_id);
+    CREATE INDEX IF NOT EXISTS idx_ak_user_name ON ak_records(user_name);
+    CREATE INDEX IF NOT EXISTS idx_ak_email ON ak_records(email);
+    CREATE INDEX IF NOT EXISTS idx_ak_phone ON ak_records(phone);
+    CREATE INDEX IF NOT EXISTS idx_ak_key_search_prefix ON ak_records(key_search_prefix);
+    CREATE INDEX IF NOT EXISTS idx_ak_updated_at ON ak_records(updated_at);
+  `);
+  return database;
+}
+
+// src/ak/repository.ts
+import Database2 from "better-sqlite3";
+var AkDuplicateRecordError = class extends Error {
+  constructor(id) {
+    super(`API key record already exists: ${id}.`);
+    this.name = "AkDuplicateRecordError";
+  }
+};
+var AkRepository = class {
+  #database;
+  constructor(database) {
+    this.#database = database;
+  }
+  insert(record) {
+    try {
+      this.#database.prepare(
+        `INSERT INTO ak_records (
+            id,
+            env,
+            user_id,
+            user_name,
+            email,
+            phone,
+            key_ciphertext,
+            key_search_prefix,
+            created_at,
+            updated_at
+          ) VALUES (
+            @id,
+            @env,
+            @userId,
+            @userName,
+            @email,
+            @phone,
+            @keyCiphertext,
+            @keySearchPrefix,
+            @createdAt,
+            @updatedAt
+          )`
+      ).run(record);
+    } catch (error) {
+      if (error instanceof Database2.SqliteError && error.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+        throw new AkDuplicateRecordError(record.id);
+      }
+      throw error;
+    }
+  }
+  getById(id) {
+    const row = this.#database.prepare("SELECT * FROM ak_records WHERE id = ?").get(id);
+    return row ? mapRowToRecord(row) : null;
+  }
+  getByEnvAndId(env, id) {
+    const row = this.#database.prepare("SELECT * FROM ak_records WHERE env = ? AND id = ?").get(env, id);
+    return row ? mapRowToRecord(row) : null;
+  }
+  list(filters) {
+    const conditions = [];
+    const params = [];
+    if (filters.env) {
+      conditions.push("env = ?");
+      params.push(filters.env);
+    }
+    if (filters.query && filters.fields && filters.fields.length > 0) {
+      const normalizedQuery = filters.query.toLowerCase();
+      const fieldConditions = filters.fields.map((field) => {
+        if (field === "key") {
+          params.push(`${filters.query}%`);
+          return "key_search_prefix LIKE ?";
+        }
+        const column = fieldToColumn(field);
+        params.push(`%${normalizedQuery}%`);
+        return `LOWER(COALESCE(${column}, '')) LIKE ?`;
+      });
+      conditions.push(`(${fieldConditions.join(" OR ")})`);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    params.push(filters.limit);
+    const rows = this.#database.prepare(
+      `SELECT * FROM ak_records
+         ${whereClause}
+         ORDER BY updated_at DESC
+         LIMIT ?`
+    ).all(...params);
+    return rows.map(mapRowToRecord);
+  }
+  updateMetadata(input2) {
+    const current = this.getById(input2.id);
+    if (!current) {
+      return null;
+    }
+    const row = this.#database.prepare(
+      `UPDATE ak_records
+         SET user_id = @userId,
+             user_name = @userName,
+             email = @email,
+             phone = @phone,
+             updated_at = @updatedAt
+         WHERE id = @id
+         RETURNING *`
+    ).get({
+      email: input2.email === void 0 ? current.email : input2.email,
+      id: input2.id,
+      phone: input2.phone === void 0 ? current.phone : input2.phone,
+      updatedAt: input2.updatedAt,
+      userId: input2.userId === void 0 ? current.userId : input2.userId,
+      userName: input2.userName === void 0 ? current.userName : input2.userName
+    });
+    if (!row) {
+      return null;
+    }
+    return mapRowToRecord(row);
+  }
+  deleteById(id) {
+    const result = this.#database.prepare("DELETE FROM ak_records WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+};
+function fieldToColumn(field) {
+  switch (field) {
+    case "userId":
+      return "user_id";
+    case "userName":
+      return "user_name";
+    case "email":
+      return "email";
+    case "phone":
+      return "phone";
+  }
+}
+function mapRowToRecord(row) {
+  return {
+    createdAt: row.created_at,
+    email: row.email,
+    env: row.env,
+    id: row.id,
+    keyCiphertext: row.key_ciphertext,
+    keySearchPrefix: row.key_search_prefix,
+    phone: row.phone,
+    updatedAt: row.updated_at,
+    userId: row.user_id,
+    userName: row.user_name
+  };
+}
+
+// src/disk/runtime.ts
+import { readdir, rm, stat } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { join as join3, win32 as win325 } from "path";
+var execFileAsync = promisify(execFile);
+function resolveDiskCleanupRoots(env) {
+  const userProfileRoot = env.USERPROFILE ?? resolveHomeDrivePath(env);
+  const systemRoot = env.SystemRoot ?? "C:\\Windows";
+  if (!userProfileRoot) {
+    throw new Error(
+      "Windows user profile could not be resolved. Set USERPROFILE or HOMEDRIVE and HOMEPATH."
+    );
+  }
+  return {
+    systemRoot,
+    userProfileRoot
+  };
+}
+function createDiskCleanupRuntime(dependencies = {}) {
+  const executeCommand = dependencies.executeCommand ?? /* v8 ignore next 3 */
+  (async (file, args) => {
+    await execFileAsync(file, args);
+  });
+  return {
+    clearDirectoryContents: async (path) => {
+      const entries = await readdir(path, { withFileTypes: true });
+      await Promise.all(
+        entries.map(
+          (entry) => rm(join3(path, entry.name), {
+            force: true,
+            recursive: true
+          })
+        )
+      );
+    },
+    disableHibernation: async () => {
+      await executeCommand("powercfg", ["-h", "off"]);
+    },
+    inspectPath: async (path) => inspectPath(path),
+    listTopEntriesBySize: async (path, limit) => listTopEntriesBySize(path, limit),
+    runCommand: async (file, args) => {
+      await executeCommand(file, args);
+    }
+  };
+}
+async function inspectPath(path) {
+  try {
+    const stats = await stat(path);
+    if (!stats.isDirectory()) {
+      return {
+        exists: true,
+        isDirectory: false,
+        sizeBytes: stats.size
+      };
+    }
+    const sizeBytes = await getDirectorySize(path);
+    return {
+      exists: true,
+      isDirectory: true,
+      sizeBytes
+    };
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return {
+        exists: false,
+        isDirectory: false,
+        sizeBytes: 0
+      };
+    }
+    throw error;
+  }
+}
+async function getDirectorySize(path) {
+  const entries = await readdir(path, { withFileTypes: true });
+  let total = 0;
+  for (const entry of entries) {
+    const entryPath = join3(path, entry.name);
+    if (entry.isDirectory()) {
+      total += await getDirectorySize(entryPath);
+      continue;
+    }
+    if (entry.isFile()) {
+      total += (await stat(entryPath)).size;
+    }
+  }
+  return total;
+}
+async function listTopEntriesBySize(path, limit) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    const measured = await Promise.all(
+      entries.map(async (entry) => {
+        const entryPath = join3(path, entry.name);
+        if (entry.isDirectory()) {
+          return {
+            kind: "directory",
+            name: entry.name,
+            path: entryPath,
+            sizeBytes: await getDirectorySize(entryPath),
+            sizeGB: 0
+          };
+        }
+        if (entry.isFile()) {
+          const stats = await stat(entryPath);
+          return {
+            kind: "file",
+            name: entry.name,
+            path: entryPath,
+            sizeBytes: stats.size,
+            sizeGB: 0
+          };
+        }
+        return null;
+      })
+    );
+    return measured.filter((entry) => entry !== null).map((entry) => ({
+      ...entry,
+      sizeGB: bytesToGb2(entry.sizeBytes)
+    })).sort((left, right) => right.sizeBytes - left.sizeBytes).slice(0, limit);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function bytesToGb2(value) {
+  return Number((value / 1024 ** 3).toFixed(2));
+}
+function resolveHomeDrivePath(env) {
+  if (!env.HOMEDRIVE || !env.HOMEPATH) {
+    return null;
+  }
+  return win325.join(env.HOMEDRIVE, env.HOMEPATH);
+}
+function isNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/video/runtime.ts
+import { execFile as nodeExecFile } from "child_process";
+import { writeFile as writeFileOnDisk } from "fs/promises";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(nodeExecFile);
+function createDefaultVideoRuntime() {
+  return {
+    execFile: async (file, args) => {
+      try {
+        const result = await execFileAsync2(file, args, { encoding: "utf8" });
+        return {
+          code: 0,
+          stderr: result.stderr,
+          stdout: result.stdout
+        };
+      } catch (error) {
+        const execError = error;
+        return {
+          code: typeof execError.code === "number" ? execError.code : 1,
+          stderr: execError.stderr ?? execError.message,
+          stdout: execError.stdout ?? ""
+        };
+      }
+    },
+    fetch: async (input2, init) => {
+      const response = await fetch(input2, init);
+      return response;
+    },
+    launchBrowserSniffer: async (url) => sniffWithBrowserRuntime(url),
+    writeFile: async (path, data) => {
+      await writeFileOnDisk(path, data);
+    }
+  };
+}
+async function sniffWithBrowserRuntime(url, loadModule = loadOptionalModule2) {
+  let playwright;
+  try {
+    playwright = await loadModule("playwright");
+  } catch {
+    throw new VideoCommandError(
+      "VIDEO_BROWSER_UNAVAILABLE",
+      "Browser sniff mode requires Playwright to be installed.",
+      2,
+      void 0,
+      true
+    );
+  }
+  const chromium = playwright.chromium;
+  if (!chromium) {
+    throw new VideoCommandError(
+      "VIDEO_BROWSER_UNAVAILABLE",
+      "Browser sniff mode requires Playwright Chromium support.",
+      2,
+      void 0,
+      true
+    );
+  }
+  const browser = await chromium.launch({ headless: true });
+  const candidates = [];
+  try {
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    page.on("response", (response) => {
+      const candidate = createCandidateFromBrowserResponse(response.url(), response.headers()["content-type"]);
+      if (candidate) {
+        candidates.push(candidate);
+      }
+    });
+    await page.goto(url, { waitUntil: "load" });
+    await page.waitForTimeout(6e4);
+    await context.close();
+  } finally {
+    await browser.close();
+  }
+  return rankVideoCandidates(candidates);
+}
+var loadOptionalModule2 = new Function(
+  "specifier",
+  "return import(specifier);"
+);
+var VIDEO_RES_RE = /(?:^|\/)(?:avc1\/|vid\/)(?:\d+\/){0,2}(\d+)x(\d+)/i;
+var AUDIO_BITRATE_RE = /\/mp4a\/(\d+)/i;
+var AUDIO_RE = /\/mp4a\//i;
+function createCandidateFromBrowserResponse(url, contentType) {
+  const isAudio = AUDIO_RE.test(url);
+  let qualityBonus = 0;
+  if (isAudio) {
+    const bitrateMatch = AUDIO_BITRATE_RE.exec(url);
+    if (bitrateMatch && bitrateMatch[1]) {
+      const bitrate = parseInt(bitrateMatch[1], 10);
+      qualityBonus = Math.min(bitrate / 192e3, 1) * 0.05;
+    }
+  } else {
+    const resMatch = VIDEO_RES_RE.exec(url);
+    if (resMatch && resMatch[1] && resMatch[2]) {
+      const width = parseInt(resMatch[1], 10);
+      const height = parseInt(resMatch[2], 10);
+      const pixels = width * height;
+      qualityBonus = Math.min(pixels / (1920 * 1080), 1) * 0.05;
+    }
+  }
+  if (/\.m4s(?:\?|$)/i.test(url)) {
+    return null;
+  }
+  if (/\.m3u8(?:\?|$)/i.test(url)) {
+    if (isAudio) {
+      return null;
+    }
+    return createVideoCandidate("m3u8", url, "network", qualityBonus);
+  }
+  if (/\.mp4(?:\?|$)/i.test(url) || contentType?.includes("video/mp4")) {
+    if (isAudio) {
+      return null;
+    }
+    return createVideoCandidate("mp4", url, "network", qualityBonus);
+  }
+  return null;
+}
+
+// src/36kr/runtime.ts
+import { execFile as nodeExecFile2 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(nodeExecFile2);
+function createDefaultKr36Runtime() {
+  return {
+    fetchArticleHtml: async (request) => fetchWithCurl(request, "KR36_REQUEST_FAILED"),
+    fetchJson: async (request) => fetchWithCurl(request, "KR36_REQUEST_FAILED")
+  };
+}
+async function fetchWithCurl(request, errorCode) {
+  const args = [
+    "--silent",
+    "--show-error",
+    "--location",
+    "--compressed",
+    ...Object.entries(request.headers).flatMap(([name, value]) => ["--header", `${name}: ${value}`]),
+    ..."body" in request ? ["--data-raw", JSON.stringify(request.body)] : [],
+    request.url
+  ];
+  try {
+    const result = await execFileAsync3("curl", args, {
+      encoding: "utf8",
+      maxBuffer: 20 * 1024 * 1024
+    });
+    return result.stdout;
+  } catch (error) {
+    const execError = error;
+    throw new Kr36CommandError(
+      errorCode,
+      `Failed to fetch 36kr page: ${execError.stderr || execError.message}`,
+      1,
+      {
+        curlExitCode: execError.code,
+        url: request.url
+      }
+    );
+  }
+}
+
+// src/toutiao/runtime.ts
+var TOUTIAO_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+function createDefaultToutiaoRuntime() {
+  return {
+    fetchArticle: async (request) => fetchArticleWithBrowser(request),
+    fetchAuthorArticles: async (options) => fetchAuthorArticlesWithBrowser(options),
+    fetchKeywordInformation: async (options) => fetchKeywordInformationWithBrowser(options),
+    fetchTechnologyChannel: async (options) => fetchTechnologyChannelWithBrowser(options)
+  };
+}
+async function fetchArticleWithBrowser(request) {
+  return withToutiaoPage(async (page) => {
+    await page.goto(request.url, {
+      timeout: 45e3,
+      waitUntil: "domcontentloaded"
+    });
+    await page.waitForTimeout(5e3);
+    const title = await page.locator("h1").first().innerText({ timeout: 5e3 }).catch(() => "");
+    const paragraphs = await page.locator("article p").evaluateAll(
+      (nodes) => nodes.map((node) => (node.textContent ?? "").trim()).filter(Boolean)
+    );
+    const bodyText = await page.locator("body").innerText({ timeout: 5e3 });
+    const metadata = extractArticleMetadata(bodyText, title);
+    const id = extractArticleId(request.url) ?? extractArticleId(request.input) ?? "";
+    if (!id || !title || paragraphs.length === 0) {
+      throw new ToutiaoCommandError(
+        "TOUTIAO_PARSE_ERROR",
+        "Toutiao article page did not expose title and content.",
+        2,
+        {
+          input: request.input,
+          url: request.url
+        }
+      );
+    }
+    const article = {
+      content: {
+        paragraphs,
+        text: paragraphs.join("\n")
+      },
+      id,
+      request,
+      title,
+      url: page.url()
+    };
+    if (metadata.authorName !== void 0) {
+      article.authorName = metadata.authorName;
+    }
+    if (metadata.publishTimeText !== void 0) {
+      article.publishTimeText = metadata.publishTimeText;
+    }
+    return article;
+  });
+}
+async function fetchTechnologyChannelWithBrowser(options) {
+  return withToutiaoPage(async (page) => {
+    const feedResponses = [];
+    page.on("response", (response) => {
+      if (!response.url().includes("/api/pc/list/feed")) {
+        return;
+      }
+      void response.json().then((json) => {
+        feedResponses.push(json);
+      }).catch(() => void 0);
+    });
+    await page.goto("https://www.toutiao.com/?channel=tech&source=ch", {
+      timeout: 45e3,
+      waitUntil: "domcontentloaded"
+    });
+    await waitForFeedResponses(page, feedResponses, options.pages);
+    const items = feedResponses.flatMap((response) => mapFeedItems(response.data ?? []));
+    const lastResponse = feedResponses.at(-1);
+    if (items.length === 0) {
+      throw new ToutiaoCommandError(
+        "TOUTIAO_PARSE_ERROR",
+        "Toutiao technology channel did not return feed items.",
+        2
+      );
+    }
+    const result = {
+      hasMore: lastResponse?.has_more ?? false,
+      items,
+      source: "tech"
+    };
+    const next = {};
+    if (lastResponse?.next?.max_behot_time !== void 0) {
+      next.maxBehotTime = lastResponse.next.max_behot_time;
+    }
+    if (lastResponse?.offset !== void 0) {
+      next.offset = lastResponse.offset;
+    }
+    if (Object.keys(next).length > 0) {
+      result.next = next;
+    }
+    return result;
+  });
+}
+async function fetchAuthorArticlesWithBrowser(options) {
+  return withToutiaoPage(async (page) => {
+    const feedResponses = [];
+    page.on("response", (response) => {
+      if (!isAuthorFeedResponseUrl(response.url(), options.authorToken)) {
+        return;
+      }
+      void response.json().then((json) => {
+        feedResponses.push(json);
+      }).catch(() => void 0);
+    });
+    await page.goto(options.url, {
+      timeout: 45e3,
+      waitUntil: "domcontentloaded"
+    });
+    await waitForFeedResponses(page, feedResponses, options.pages);
+    const seen = /* @__PURE__ */ new Set();
+    const selectedResponses = feedResponses.slice(0, options.pages);
+    const items = selectedResponses.flatMap((response) => mapFeedItems(response.data ?? [])).filter((item) => {
+      if (seen.has(item.id)) {
+        return false;
+      }
+      seen.add(item.id);
+      return true;
+    });
+    const lastResponse = selectedResponses.at(-1);
+    if (items.length === 0) {
+      throw new ToutiaoCommandError(
+        "TOUTIAO_PARSE_ERROR",
+        "Toutiao author homepage did not return article feed items.",
+        2,
+        {
+          authorToken: options.authorToken,
+          url: options.url
+        }
+      );
+    }
+    const result = {
+      authorToken: options.authorToken,
+      hasMore: lastResponse?.has_more ?? false,
+      items
+    };
+    const next = {};
+    if (lastResponse?.next?.max_behot_time !== void 0) {
+      next.maxBehotTime = lastResponse.next.max_behot_time;
+    }
+    if (lastResponse?.offset !== void 0) {
+      next.offset = lastResponse.offset;
+    }
+    if (Object.keys(next).length > 0) {
+      result.next = next;
+    }
+    return result;
+  });
+}
+async function fetchKeywordInformationWithBrowser(options) {
+  return withToutiaoPage(async (page) => {
+    const items = [];
+    const seen = /* @__PURE__ */ new Set();
+    let blocked = false;
+    for (let pageIndex = 0; pageIndex < options.pages; pageIndex += 1) {
+      const url = buildSearchUrl(options.keyword, pageIndex);
+      await page.goto(url, {
+        timeout: 45e3,
+        waitUntil: "domcontentloaded"
+      });
+      await page.waitForTimeout(5e3);
+      blocked = blocked || await page.locator("#pc_captcha").count() > 0;
+      for (const item of await extractSearchItemsFromPage(page, options.keyword)) {
+        if (seen.has(item.id)) {
+          continue;
+        }
+        seen.add(item.id);
+        items.push(item);
+      }
+    }
+    if (blocked && items.length === 0) {
+      throw new ToutiaoCommandError(
+        "TOUTIAO_VERIFICATION_REQUIRED",
+        "Toutiao search requires browser verification before returning usable results.",
+        1,
+        {
+          keyword: options.keyword
+        }
+      );
+    }
+    if (items.length === 0) {
+      throw new ToutiaoCommandError(
+        "TOUTIAO_PARSE_ERROR",
+        "Toutiao search page did not expose result items.",
+        2,
+        {
+          keyword: options.keyword
+        }
+      );
+    }
+    return {
+      hasMore: true,
+      items,
+      keyword: options.keyword,
+      source: options.source
+    };
+  });
+}
+function buildSearchUrl(keyword, pageIndex) {
+  const params = new URLSearchParams({
+    action_type: pageIndex === 0 ? "search" : "pagination",
+    cur_tab_title: "news",
+    dvpf: "pc",
+    from: "news",
+    keyword,
+    page_num: String(pageIndex),
+    pd: "information",
+    source: pageIndex === 0 ? "input" : "pagination"
+  });
+  return `https://so.toutiao.com/search?${params.toString()}`;
+}
+async function withToutiaoPage(callback) {
+  let browser;
+  let context;
+  try {
+    const { chromium } = await loadPlaywright();
+    browser = await chromium.launch({ headless: true });
+    context = await browser.newContext({
+      locale: "zh-CN",
+      userAgent: TOUTIAO_USER_AGENT
+    });
+    const page = await context.newPage();
+    return await callback(page);
+  } finally {
+    await context?.close().catch(() => void 0);
+    await browser?.close().catch(() => void 0);
+  }
+}
+async function waitForFeedResponses(page, responses, pages) {
+  const started = Date.now();
+  while (responses.length < pages && Date.now() - started < 45e3) {
+    await page.waitForTimeout(1e3);
+    if (responses.length < pages) {
+      await page.mouse.wheel(0, 4e3);
+    }
+  }
+}
+async function loadPlaywright() {
+  try {
+    return await loadOptionalModule3("playwright");
+  } catch {
+    throw new ToutiaoCommandError(
+      "TOUTIAO_BROWSER_UNAVAILABLE",
+      "Toutiao collection requires Playwright to be installed.",
+      2
+    );
+  }
+}
+function mapFeedItems(items) {
+  return items.flatMap((item) => {
+    const id = String(item.group_id ?? item.item_id ?? item.id ?? "");
+    const title = item.title ?? item.Title ?? "";
+    if (!id || !title) {
+      return [];
+    }
+    const mapped = {
+      id,
+      title,
+      url: normalizeArticleUrl(item.article_url ?? item.display_url ?? item.source_url, id)
+    };
+    const abstract = item.Abstract ?? item.abstract;
+    if (abstract !== void 0) {
+      mapped.abstract = abstract;
+    }
+    if (item.comment_count !== void 0) {
+      mapped.commentCount = item.comment_count;
+    }
+    if (item.image_url !== void 0) {
+      mapped.image = item.image_url;
+    }
+    const authorName = item.media_name ?? item.source;
+    if (authorName !== void 0) {
+      mapped.authorName = authorName;
+    }
+    if (item.source_url !== void 0) {
+      mapped.sourceUrl = item.source_url;
+    }
+    if (item.behot_time !== void 0) {
+      mapped.publishTime = {
+        iso: new Date(item.behot_time * 1e3).toISOString(),
+        local: formatChinaTime2(item.behot_time),
+        seconds: item.behot_time
+      };
+    }
+    return [mapped];
+  });
+}
+function normalizeArticleUrl(value, id) {
+  if (!value) {
+    return `https://www.toutiao.com/article/${id}/`;
+  }
+  try {
+    const url = new URL(value, "https://www.toutiao.com");
+    return parseToutiaoArticleLink(url.toString())?.url ?? `https://www.toutiao.com/article/${id}/`;
+  } catch {
+    return `https://www.toutiao.com/article/${id}/`;
+  }
+}
+async function extractSearchItemsFromPage(page, keyword) {
+  const anchors = await page.locator("a").evaluateAll(
+    (nodes) => nodes.map((node) => ({
+      href: node.href,
+      text: (node.textContent ?? "").trim().replace(/\s+/g, " ")
+    }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const anchor of anchors) {
+    const articleLink = parseToutiaoArticleLink(anchor.href);
+    if (!articleLink || !anchor.text || anchor.text.length < 6 || seen.has(articleLink.id)) {
+      continue;
+    }
+    seen.add(articleLink.id);
+    items.push({
+      id: articleLink.id,
+      title: anchor.text.slice(0, 180),
+      url: articleLink.url
+    });
+    if (items.length >= 30) {
+      break;
+    }
+  }
+  if (items.length > 0) {
+    return items;
+  }
+  return extractSearchItemsFromText(await page.locator("body").innerText({ timeout: 5e3 }), keyword);
+}
+function extractSearchItemsFromText(text, keyword) {
+  const blockedPrefixes = /* @__PURE__ */ new Set([
+    "\u65E0\u969C\u788D \u4ECA\u65E5\u5934\u6761\u9996\u9875 \u767B\u5F55 \u7EFC\u5408 \u8D44\u8BAF \u89C6\u9891 \u56FE\u7247 \u7528\u6237 \u5C0F\u89C6\u9891 \u5FAE\u5934\u6761 \u97F3\u4E50 \u53BB\u6296\u97F3\u641C"
+  ]);
+  const lines = text.split(/\n+/).map((line) => line.trim()).filter((line) => line.length >= 12 && !blockedPrefixes.has(line));
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const line of lines) {
+    const normalized = line.replace(/\s+/g, " ");
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    items.push({
+      id: createSearchItemId(keyword, normalized, items.length),
+      title: normalized.slice(0, 180),
+      url: `https://so.toutiao.com/search?keyword=${encodeURIComponent(keyword)}&pd=information&dvpf=pc&source=input`
+    });
+    if (items.length >= 30) {
+      break;
+    }
+  }
+  return items;
+}
+function parseToutiaoArticleLink(href, depth = 0) {
+  if (depth > 3) {
+    return void 0;
+  }
+  const directId = extractArticleId(href);
+  if (directId) {
+    return {
+      id: directId,
+      url: `https://www.toutiao.com/article/${directId}/`
+    };
+  }
+  try {
+    const url = new URL(href);
+    const nextUrl = url.searchParams.get("url");
+    if (nextUrl) {
+      return parseToutiaoArticleLink(nextUrl, depth + 1);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function extractArticleMetadata(bodyText, title) {
+  const lines = bodyText.split(/\n+/).map((line) => line.trim()).filter(Boolean);
+  const titleIndex = lines.findIndex((line) => line === title);
+  const metadataLine = titleIndex >= 0 ? lines[titleIndex + 1] : void 0;
+  const match = metadataLine?.match(/^(.+?)·(.+)$/);
+  if (!match?.[1] || !match[2]) {
+    return {};
+  }
+  return {
+    authorName: match[2],
+    publishTimeText: match[1]
+  };
+}
+function extractArticleId(value) {
+  return /(?:article|group)\/(\d+)/.exec(value)?.[1] ?? /\/a(\d+)/.exec(value)?.[1] ?? (/^\d+$/.test(value) ? value : void 0);
+}
+function isAuthorFeedResponseUrl(value, authorToken) {
+  try {
+    const url = new URL(value);
+    const isProfileArticleFeed = url.pathname.includes("/api/pc/list/feed") && (url.searchParams.get("category") === "pc_profile_article" || url.searchParams.get("author_token") === authorToken);
+    const isProfileAllFeed = url.pathname.includes("/api/pc/list/user/feed") && url.searchParams.get("category") === "profile_all" && url.searchParams.get("token") === authorToken;
+    return isProfileArticleFeed || isProfileAllFeed;
+  } catch {
+    return value.includes("/api/pc/list/feed") && (value.includes("pc_profile_article") || value.includes(authorToken)) || value.includes("/api/pc/list/user/feed") && value.includes("profile_all") && value.includes(authorToken);
+  }
+}
+function createSearchItemId(keyword, value, index) {
+  let hash = 2166136261;
+  const input2 = `${keyword}:${index}:${value}`;
+  for (const char of input2) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `search-${(hash >>> 0).toString(16)}`;
+}
+function formatChinaTime2(timestampSeconds) {
+  return new Intl.DateTimeFormat("sv-SE", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    second: "2-digit",
+    timeZone: "Asia/Shanghai",
+    year: "numeric"
+  }).format(new Date(timestampSeconds * 1e3));
+}
+var loadOptionalModule3 = new Function(
+  "specifier",
+  "return import(specifier);"
+);
+
+// src/hn/runtime.ts
+var FIREBASE_BASE_URL = "https://hacker-news.firebaseio.com/v0";
+var ALGOLIA_BASE_URL = "https://hn.algolia.com/api/v1";
+var SOURCE_TO_ENDPOINT = {
+  best: "beststories",
+  new: "newstories",
+  top: "topstories"
+};
+function createDefaultHackerNewsRuntime() {
+  return {
+    fetchSearch: async (options) => fetchSearch(options),
+    fetchStories: async (options) => fetchStories(options)
+  };
+}
+async function fetchStories(options) {
+  const endpoint = SOURCE_TO_ENDPOINT[options.source];
+  const ids = await fetchJson(`${FIREBASE_BASE_URL}/${endpoint}.json`);
+  const selectedIds = ids.slice(0, Math.max(options.limit * 2, options.limit));
+  const rawItems = await Promise.all(
+    selectedIds.map((id) => fetchJson(`${FIREBASE_BASE_URL}/item/${id}.json`))
+  );
+  const items = rawItems.flatMap((item) => mapFirebaseItem(item)).slice(0, options.limit);
+  return {
+    items,
+    source: options.source
+  };
+}
+async function fetchSearch(options) {
+  const params = new URLSearchParams({
+    hitsPerPage: String(options.limit),
+    query: options.query,
+    tags: "story"
+  });
+  const endpoint = options.sort === "date" ? "search_by_date" : "search";
+  const response = await fetchJson(`${ALGOLIA_BASE_URL}/${endpoint}?${params.toString()}`);
+  return {
+    items: response.hits.flatMap(mapAlgoliaHit).slice(0, options.limit),
+    query: options.query
+  };
+}
+async function fetchJson(url) {
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: {
+        accept: "application/json",
+        "user-agent": "stephen-cli/0.1 HackerNews collector"
+      }
+    });
+  } catch (error) {
+    throw new HackerNewsCommandError(
+      "HN_FETCH_FAILED",
+      "Failed to fetch Hacker News data.",
+      2,
+      {
+        cause: error instanceof Error ? error.message : String(error),
+        url
+      }
+    );
+  }
+  if (!response.ok) {
+    throw new HackerNewsCommandError(
+      "HN_FETCH_FAILED",
+      `Failed to fetch Hacker News data. HTTP ${response.status}.`,
+      2,
+      {
+        url
+      }
+    );
+  }
+  return await response.json();
+}
+function mapFirebaseItem(item) {
+  if (!item || item.deleted || item.dead || item.type !== "story" || !item.id || !item.title) {
+    return [];
+  }
+  return [
+    createItem({
+      id: item.id,
+      title: item.title,
+      url: item.url ?? `https://news.ycombinator.com/item?id=${item.id}`,
+      ...optional("author", item.by),
+      ...optional("commentCount", item.descendants),
+      ...optional("score", item.score),
+      ...optional("text", item.text),
+      ...optional("timeSeconds", item.time)
+    })
+  ];
+}
+function mapAlgoliaHit(hit) {
+  const id = hit.story_id ?? parseNumericId(hit.objectID);
+  if (!id || !hit.title) {
+    return [];
+  }
+  return [
+    createItem({
+      id,
+      title: hit.title,
+      url: hit.url ?? `https://news.ycombinator.com/item?id=${id}`,
+      ...optional("author", hit.author),
+      ...optional("commentCount", hit.num_comments),
+      ...optional("score", hit.points),
+      ...optional("timeSeconds", hit.created_at_i)
+    })
+  ];
+}
+function createItem(input2) {
+  const item = {
+    id: input2.id,
+    title: input2.title,
+    type: "story",
+    url: input2.url
+  };
+  if (input2.author !== void 0) {
+    item.author = input2.author;
+  }
+  if (input2.commentCount !== void 0) {
+    item.commentCount = input2.commentCount;
+  }
+  if (input2.score !== void 0) {
+    item.score = input2.score;
+  }
+  if (input2.text !== void 0) {
+    item.text = input2.text;
+  }
+  if (input2.timeSeconds !== void 0) {
+    item.time = {
+      iso: new Date(input2.timeSeconds * 1e3).toISOString(),
+      seconds: input2.timeSeconds
+    };
+  }
+  return item;
+}
+function parseNumericId(value) {
+  if (!value || !/^\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number(value);
+}
+
+// src/index.ts
+var createDefaultReadline = () => createInterface({ input, output });
+function createCli(overrides = {}) {
+  const paths = overrides.paths ?? envPaths("stephen");
+  const runtimeEnv = overrides.env ?? process.env;
+  const masterKey = overrides.masterKey ?? Buffer.from("0123456789abcdef0123456789abcdef", "utf8");
+  const diskRuntime = overrides.diskRuntime ?? createDiskCleanupRuntime();
+  const hackerNewsRuntime = overrides.hackerNewsRuntime ?? createDefaultHackerNewsRuntime();
+  const kr36Runtime = overrides.kr36Runtime ?? createDefaultKr36Runtime();
+  const toutiaoRuntime = overrides.toutiaoRuntime ?? createDefaultToutiaoRuntime();
+  const videoRuntime = overrides.videoRuntime ?? createDefaultVideoRuntime();
+  let repositoryCache = overrides.repository ? { promise: Promise.resolve(overrides.repository), repository: overrides.repository } : null;
+  const getRepository = () => {
+    if (repositoryCache && overrides.repository) {
+      return overrides.repository;
+    }
+    if (!repositoryCache) {
+      const config = loadAkConfig(paths.config);
+      const resolvedDatabasePath = resolveAkDatabasePath({
+        config,
+        defaultDataDir: paths.data,
+        env: runtimeEnv
+      });
+      mkdirSync2(dirname2(resolvedDatabasePath.path), { recursive: true });
+      let repository;
+      try {
+        repository = new AkRepository(createAkDatabase(resolvedDatabasePath.path));
+      } catch (error) {
+        throw new AkStorageInitError(resolvedDatabasePath.path, error);
+      }
+      repositoryCache = { promise: Promise.resolve(repository), repository };
+    }
+    return repositoryCache.repository;
+  };
+  return createAkCli({
+    confirm: overrides.confirm ?? defaultConfirm,
+    diskRuntime,
+    env: runtimeEnv,
+    getRepository,
+    hackerNewsRuntime,
+    kr36Runtime,
+    masterKey,
+    now: overrides.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
+    paths,
+    resolveDiskCleanupRoots: () => resolveDiskCleanupRoots(runtimeEnv),
+    stderr: overrides.stderr ?? ((value) => process.stderr.write(value)),
+    stdout: overrides.stdout ?? ((value) => process.stdout.write(value)),
+    toutiaoRuntime,
+    videoRuntime
+  });
+}
+async function defaultConfirm(message, createReadline = createDefaultReadline) {
+  const readline = createReadline();
+  try {
+    const answer = await readline.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    readline.close();
+  }
+}
+function isMainEntrypoint(moduleUrl, argv) {
+  const scriptPath = argv[1];
+  if (!scriptPath) {
+    return false;
+  }
+  return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(scriptPath);
+}
+if (isMainEntrypoint(import.meta.url, process.argv)) {
+  const cli = createCli();
+  void cli.run(process.argv.slice(2)).then((exitCode) => {
+    process.exitCode = exitCode;
+  });
+}
+export {
+  createCli,
+  defaultConfirm,
+  isMainEntrypoint
+};
+//# sourceMappingURL=index.js.map