@c0sc0s/codex-tags 0.5.0

package/runtime/src/search-index.mjs

@@ -0,0 +1,191 @@
+import { chmodSync, existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import Database from "better-sqlite3";
+
+import { discoverSessionFiles, extractConversationText } from "./content-index.mjs";
+
+const defaultResultLimit = 50;
+const maximumResultLimit = 100;
+const extractionVersion = 1;
+
+function localThreadIdFor(threadId) {
+  return threadId.includes(":") ? threadId.slice(threadId.lastIndexOf(":") + 1) : threadId;
+}
+
+function quotedFtsQuery(query) {
+  return `"${query.replaceAll('"', '""')}"`;
+}
+
+function buildSnippet(text, query) {
+  const normalized = text.replace(/\s+/gu, " ");
+  const matchIndex = normalized.toLocaleLowerCase().indexOf(query.toLocaleLowerCase());
+  if (matchIndex === -1) return normalized.slice(0, 132);
+  const start = Math.max(0, matchIndex - 46);
+  const end = Math.min(normalized.length, matchIndex + query.length + 82);
+  return `${start > 0 ? "…" : ""}${normalized.slice(start, end)}${end < normalized.length ? "…" : ""}`;
+}
+
+export class SessionSearchIndex {
+  constructor(databasePath, options = {}) {
+    this.discoverFiles = options.discoverFiles ?? (() => discoverSessionFiles(true));
+    this.readOnly = options.readOnly === true;
+    this.database = new Database(databasePath, {
+      readonly: this.readOnly,
+      fileMustExist: this.readOnly,
+      timeout: 5000,
+    });
+    if (!this.readOnly) this.database.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      CREATE TABLE IF NOT EXISTS indexed_sessions (
+        thread_id TEXT PRIMARY KEY,
+        file_path TEXT NOT NULL,
+        file_size INTEGER NOT NULL,
+        modified_at REAL NOT NULL
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS session_messages USING fts5(
+        thread_id UNINDEXED,
+        role UNINDEXED,
+        content,
+        tokenize = 'trigram'
+      );
+    `);
+    if (!this.readOnly) {
+      // Cached file timestamps cannot detect changes to the transcript extractor.
+      if (this.database.pragma("user_version", { simple: true }) < extractionVersion) {
+        this.database.transaction(() => {
+          this.database.exec("DELETE FROM session_messages; DELETE FROM indexed_sessions;");
+          this.database.pragma(`user_version = ${extractionVersion}`);
+        })();
+      }
+      for (const path of [databasePath, `${databasePath}-wal`, `${databasePath}-shm`]) {
+        if (existsSync(path)) chmodSync(path, 0o600);
+      }
+    }
+    this.selectIndexedSessions = this.database.prepare("SELECT thread_id, file_path, file_size, modified_at FROM indexed_sessions");
+    if (this.readOnly) return;
+    this.deleteMessages = this.database.prepare("DELETE FROM session_messages WHERE thread_id = ?");
+    this.deleteSession = this.database.prepare("DELETE FROM indexed_sessions WHERE thread_id = ?");
+    this.insertMessage = this.database.prepare("INSERT INTO session_messages(thread_id, role, content) VALUES (?, ?, ?)");
+    this.upsertSession = this.database.prepare(`
+      INSERT INTO indexed_sessions(thread_id, file_path, file_size, modified_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(thread_id) DO UPDATE SET
+        file_path = excluded.file_path,
+        file_size = excluded.file_size,
+        modified_at = excluded.modified_at
+    `);
+    this.searchFts = this.database.prepare(`
+      SELECT thread_id, role, content, bm25(session_messages) AS rank
+      FROM session_messages
+      WHERE session_messages MATCH ?
+        AND thread_id IN (SELECT value FROM json_each(?))
+      ORDER BY rank
+      LIMIT ?
+    `);
+    this.searchShortQuery = this.database.prepare(`
+      SELECT thread_id, role, content, 0 AS rank
+      FROM session_messages
+      WHERE instr(lower(content), lower(?)) > 0
+        AND thread_id IN (SELECT value FROM json_each(?))
+      LIMIT ?
+    `);
+  }
+
+  async refresh(onProgress = () => {}) {
+    if (this.readOnly) throw new Error("Cannot refresh a read-only search index");
+    const files = await this.discoverFiles();
+    const indexed = new Map(this.selectIndexedSessions.all().map((row) => [row.thread_id, row]));
+    const entries = [...files.entries()];
+    let completed = 0;
+    let changed = 0;
+    onProgress({ phase: "indexing", completed, total: entries.length, changed });
+
+    for (const [threadId, filePath] of entries) {
+      let metadata;
+      try {
+        metadata = await stat(filePath);
+      } catch {
+        completed += 1;
+        continue;
+      }
+      const previous = indexed.get(threadId);
+      if (previous?.file_path === filePath && previous.file_size === metadata.size && previous.modified_at === metadata.mtimeMs) {
+        indexed.delete(threadId);
+        completed += 1;
+        onProgress({ phase: "indexing", completed, total: entries.length, changed });
+        continue;
+      }
+
+      const chunks = await extractConversationText(filePath);
+      this.database.exec("BEGIN IMMEDIATE");
+      try {
+        this.deleteMessages.run(threadId);
+        for (const chunk of chunks) this.insertMessage.run(threadId, chunk.role, chunk.text);
+        this.upsertSession.run(threadId, filePath, metadata.size, metadata.mtimeMs);
+        this.database.exec("COMMIT");
+      } catch (error) {
+        this.database.exec("ROLLBACK");
+        throw error;
+      }
+      indexed.delete(threadId);
+      changed += 1;
+      completed += 1;
+      onProgress({ phase: "indexing", completed, total: entries.length, changed });
+    }
+
+    for (const threadId of indexed.keys()) {
+      this.database.exec("BEGIN IMMEDIATE");
+      try {
+        this.deleteMessages.run(threadId);
+        this.deleteSession.run(threadId);
+        this.database.exec("COMMIT");
+      } catch (error) {
+        this.database.exec("ROLLBACK");
+        throw error;
+      }
+      changed += 1;
+    }
+    const result = { phase: "ready", completed: entries.length, total: entries.length, changed };
+    this.database.pragma("optimize");
+    this.database.pragma("wal_checkpoint(TRUNCATE)");
+    onProgress(result);
+    return result;
+  }
+
+  search({ query, threadIds, limit = defaultResultLimit }) {
+    if (this.readOnly) throw new Error("Cannot search through a status-only index connection");
+    const normalizedQuery = typeof query === "string" ? query.trim() : "";
+    if (!normalizedQuery || !Array.isArray(threadIds) || threadIds.length === 0) return [];
+    const boundedLimit = Math.max(1, Math.min(maximumResultLimit, Number(limit) || defaultResultLimit));
+    const originalIdByLocalId = new Map();
+    for (const threadId of threadIds) {
+      if (typeof threadId !== "string" || !threadId) continue;
+      originalIdByLocalId.set(localThreadIdFor(threadId), threadId);
+    }
+    const localThreadIds = [...originalIdByLocalId.keys()];
+    if (localThreadIds.length === 0) return [];
+    const rows = [...normalizedQuery].length < 3
+      ? this.searchShortQuery.iterate(normalizedQuery, JSON.stringify(localThreadIds), -1)
+      : this.searchFts.iterate(quotedFtsQuery(normalizedQuery), JSON.stringify(localThreadIds), -1);
+    const results = [];
+    const seenThreadIds = new Set();
+    for (const row of rows) {
+      const threadId = originalIdByLocalId.get(row.thread_id);
+      if (!threadId || seenThreadIds.has(threadId)) continue;
+      seenThreadIds.add(threadId);
+      results.push({ threadId, role: row.role, snippet: buildSnippet(row.content, normalizedQuery), score: -Number(row.rank) || 0 });
+      if (results.length >= boundedLimit) break;
+    }
+    return results;
+  }
+
+  status() {
+    const row = this.database.prepare("SELECT count(*) AS count FROM indexed_sessions").get();
+    return { indexedSessions: Number(row?.count ?? 0) };
+  }
+
+  close() {
+    this.database.close();
+  }
+}

package/runtime/src/session-catalog.mjs

@@ -0,0 +1,52 @@
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+
+function isInternalSession({ source, threadSource }) {
+  if (threadSource === "subagent" || threadSource === "guardian_review") return true;
+  if (source === "subagent") return true;
+  try {
+    const parsed = JSON.parse(source);
+    return parsed === "subagent" || (parsed !== null && typeof parsed === "object" && Object.hasOwn(parsed, "subagent"));
+  } catch {
+    return false;
+  }
+}
+
+// Keep the private Codex database schema isolated and always open it read-only.
+export class SessionCatalog {
+  constructor(root = process.env.CODEX_HOME ?? join(homedir(), ".codex")) {
+    this.root = root;
+  }
+
+  async read() {
+    let database;
+    try {
+      const files = (await readdir(this.root)).filter((name) => /^state_\d+\.sqlite$/u.test(name))
+        .sort((a, b) => Number(b.match(/\d+/u)[0]) - Number(a.match(/\d+/u)[0]));
+      if (!files.length) return { items: [], error: "Local session catalog is unavailable", complete: false };
+      database = new Database(join(this.root, files[0]), { readonly: true, fileMustExist: true, timeout: 1000 });
+      const columns = new Set(database.pragma("table_info(threads)").map(({ name }) => name));
+      for (const column of ["id", "title", "updated_at", "archived"]) {
+        if (!columns.has(column)) throw new Error("Unsupported Codex session catalog schema");
+      }
+      const title = columns.has("name") ? "COALESCE(NULLIF(name, ''), title)" : "title";
+      const time = columns.has("updated_at_ms") ? "COALESCE(updated_at_ms, updated_at * 1000)" : "updated_at * 1000";
+      const project = columns.has("project_id") ? "project_id" : "NULL";
+      const pinned = columns.has("is_pinned") ? "is_pinned" : "NULL";
+      const source = columns.has("source") ? "source" : "NULL";
+      const threadSource = columns.has("thread_source") ? "thread_source" : "NULL";
+      const rows = database.prepare(`SELECT id AS threadId, ${title} AS raw, ${time} AS updatedAt, ${project} AS projectId, ${pinned} AS pinned, ${source} AS source, ${threadSource} AS threadSource FROM threads WHERE archived = 0 ORDER BY ${time} DESC, id`).all();
+      // Older builds encode child provenance in source; newer builds also expose thread_source.
+      const items = rows.filter((row) => !isInternalSession(row)).map(({ source: _source, threadSource: _threadSource, ...row }) => ({
+        ...row, pinned: row.pinned === null ? null : Boolean(row.pinned),
+      }));
+      return { items, error: null, complete: true };
+    } catch {
+      return { items: [], error: "Local session catalog could not be read; sidebar-only results are available", complete: false };
+    } finally {
+      database?.close();
+    }
+  }
+}

package/runtime/src/settings-repository.mjs

@@ -0,0 +1,58 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+import { createTagSettings, DEFAULT_TAG_DEFINITIONS, TAG_SETTINGS_SCHEMA_VERSION } from "./tag-settings.mjs";
+
+export class SettingsRepository {
+  #serialized = null;
+  #writeQueue = Promise.resolve();
+
+  constructor(path, options = {}) {
+    this.path = path;
+    this.fallback = options.fallback ?? DEFAULT_TAG_DEFINITIONS;
+  }
+
+  async read() {
+    try {
+      const source = await readFile(this.path, "utf8");
+      const candidate = JSON.parse(source);
+      if (!candidate || typeof candidate !== "object" || ![1, TAG_SETTINGS_SCHEMA_VERSION].includes(candidate.schemaVersion) || !Array.isArray(candidate.tags)) {
+        throw new Error("Unsupported or malformed tag settings schema");
+      }
+      const settings = createTagSettings(candidate.tags);
+      this.#serialized = this.#serialize(settings);
+      return { settings, exists: true, error: null };
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        return {
+          settings: createTagSettings(this.fallback),
+          exists: false,
+          error: `Unable to read tag settings: ${error.message}`,
+        };
+      }
+      return { settings: createTagSettings(this.fallback), exists: false, error: null };
+    }
+  }
+
+  write(definitions) {
+    const operation = this.#writeQueue.then(() => this.#commit(definitions));
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    return operation;
+  }
+
+  async #commit(definitions) {
+    const settings = createTagSettings(definitions);
+    const serialized = this.#serialize(settings);
+    if (serialized === this.#serialized) return { settings, changed: false };
+    await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+    const temporaryPath = `${this.path}.next-${process.pid}`;
+    await writeFile(temporaryPath, serialized, { encoding: "utf8", mode: 0o600 });
+    await rename(temporaryPath, this.path);
+    this.#serialized = serialized;
+    return { settings, changed: true };
+  }
+
+  #serialize(settings) {
+    return `${JSON.stringify(settings, null, 2)}\n`;
+  }
+}

package/runtime/src/tag-settings.d.mts

@@ -0,0 +1,18 @@
+export interface TagDefinition {
+  name: string;
+  color: string;
+  description: string;
+}
+
+export interface TagSettings {
+  schemaVersion: 2;
+  tags: TagDefinition[];
+}
+
+export const TAG_SETTINGS_SCHEMA_VERSION: 2;
+export const TAG_COLOR_PRESETS: ReadonlyArray<Readonly<{ name: string; color: string }>>;
+export const LEGACY_TONE_COLORS: Readonly<Record<string, string>>;
+export const DEFAULT_TAG_DEFINITIONS: ReadonlyArray<Readonly<TagDefinition>>;
+
+export function normalizeTagDefinitions(value: unknown, fallback?: ReadonlyArray<Readonly<TagDefinition>>): TagDefinition[];
+export function createTagSettings(definitions: unknown): TagSettings;

package/runtime/src/tag-settings.mjs

@@ -0,0 +1,65 @@
+export const TAG_SETTINGS_SCHEMA_VERSION = 2;
+
+export const TAG_COLOR_PRESETS = Object.freeze([
+  { name: "海蓝", color: "#4f8fd7" },
+  { name: "鸢紫", color: "#956ad1" },
+  { name: "珊瑚", color: "#d95c5c" },
+  { name: "琥珀", color: "#c98b28" },
+  { name: "松绿", color: "#3f9a6b" },
+  { name: "雾灰", color: "#7c8798" },
+]);
+
+const PRESET_COLORS = Object.fromEntries(TAG_COLOR_PRESETS.map(({ name, color }) => [name, color]));
+export const LEGACY_TONE_COLORS = Object.freeze({
+  amber: PRESET_COLORS["琥珀"],
+  blue: PRESET_COLORS["海蓝"],
+  red: PRESET_COLORS["珊瑚"],
+  purple: PRESET_COLORS["鸢紫"],
+  green: PRESET_COLORS["松绿"],
+  neutral: PRESET_COLORS["雾灰"],
+});
+
+export const DEFAULT_TAG_DEFINITIONS = Object.freeze([
+  { name: "Feature", color: PRESET_COLORS["海蓝"], description: "Build or extend functionality. Use when the main goal is to implement a new capability or improve existing behavior, rather than fix a defect." },
+  { name: "Bug", color: PRESET_COLORS["珊瑚"], description: "Diagnose and fix incorrect behavior, errors, or regressions. Use when the goal is to restore expected behavior, including investigation needed for the fix." },
+  { name: "Design", color: PRESET_COLORS["鸢紫"], description: "Define how a solution should look or work: UI, interactions, architecture, or technical plans. Use when the main deliverable is a design or specification." },
+  { name: "Research", color: PRESET_COLORS["松绿"], description: "Explore a topic, understand existing code, compare options, or assess feasibility. Use when the main deliverable is findings or an explanation, rather than a design or implementation." },
+]);
+
+function normalizeColor(value, legacyTone, fallbackColor) {
+  if (typeof value === "string" && /^#[0-9a-f]{6}$/iu.test(value.trim())) return value.trim().toLocaleLowerCase();
+  return LEGACY_TONE_COLORS[legacyTone] ?? fallbackColor ?? LEGACY_TONE_COLORS.neutral;
+}
+
+function normalizeDescription(value, fallbackDescription = "") {
+  if (typeof value !== "string") return fallbackDescription;
+  return value.replace(/\s+/gu, " ").trim().slice(0, 240);
+}
+
+export function normalizeTagDefinitions(value, fallback = DEFAULT_TAG_DEFINITIONS) {
+  if (!Array.isArray(value)) return fallback.map((item) => ({ ...item }));
+  const defaultsByName = new Map(fallback.map((item) => [item.name.toLocaleLowerCase(), item]));
+  const seen = new Set();
+  const definitions = [];
+  for (const item of value) {
+    const name = typeof item?.name === "string" ? item.name.trim() : "";
+    const key = name.toLocaleLowerCase();
+    if (!name || name.length > 32 || /[\[\]【】\r\n]/u.test(name) || seen.has(key)) continue;
+    const defaultDefinition = defaultsByName.get(key);
+    seen.add(key);
+    definitions.push({
+      name,
+      color: normalizeColor(item?.color, item?.tone, defaultDefinition?.color),
+      description: normalizeDescription(item?.description, defaultDefinition?.description),
+    });
+    if (definitions.length >= 32) break;
+  }
+  return definitions;
+}
+
+export function createTagSettings(definitions) {
+  return {
+    schemaVersion: TAG_SETTINGS_SCHEMA_VERSION,
+    tags: normalizeTagDefinitions(definitions),
+  };
+}

package/runtime/src/title-format.d.mts

@@ -0,0 +1,11 @@
+export interface ParsedTitleMetadata {
+  raw: string;
+  tag: string;
+  time: string;
+  title: string;
+}
+
+export function colorForTag(tag: string): string;
+export function parseTitleMetadata(value: unknown): ParsedTitleMetadata | null;
+export function parseSidebarTitle(value: unknown): (ParsedTitleMetadata & { color: string }) | null;
+export const titlePatternSource: string;

package/runtime/src/title-format.mjs

@@ -0,0 +1,33 @@
+import { DEFAULT_TAG_DEFINITIONS, LEGACY_TONE_COLORS } from "./tag-settings.mjs";
+
+const MAX_TAG_LENGTH = 32;
+const MAX_TIME_LENGTH = 32;
+
+const BRACKETED_TITLE = /^(?:\[([^\]\r\n]{1,32})\]|【([^】\r\n]{1,32})】)(?:(?:\[([^\]\r\n]{1,32})\]|【([^】\r\n]{1,32})】))?\s*(.+)$/u;
+
+const TAG_COLORS = new Map(DEFAULT_TAG_DEFINITIONS.map(({ name, color }) => [name.toLocaleLowerCase(), color]));
+
+export function colorForTag(tag) {
+  return TAG_COLORS.get(tag.trim().toLocaleLowerCase()) ?? LEGACY_TONE_COLORS.neutral;
+}
+
+export function parseTitleMetadata(value) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  const match = BRACKETED_TITLE.exec(raw);
+  if (!match) return null;
+
+  const tag = (match[1] ?? match[2] ?? "").trim();
+  const time = (match[3] ?? match[4] ?? "").trim();
+  const title = match[5].trim();
+  if (!tag || !title || tag.length > MAX_TAG_LENGTH || time.length > MAX_TIME_LENGTH) return null;
+
+  return { raw, tag, time, title };
+}
+
+export function parseSidebarTitle(value) {
+  const parsed = parseTitleMetadata(value);
+  return parsed ? { ...parsed, color: colorForTag(parsed.tag) } : null;
+}
+
+export const titlePatternSource = BRACKETED_TITLE.source;

package/scripts/cli-options.mjs

@@ -0,0 +1,17 @@
+const commands = new Set(["install", "enable", "on", "disable", "off", "restore", "status", "doctor", "update", "uninstall", "help", "version"]);
+const flags = new Set(["--json", "--purge", "--help", "-h", "--version", "-v"]);
+
+export function parseCliOptions(args) {
+  for (const argument of args) {
+    if (argument.startsWith("-") && !flags.has(argument)) throw new Error(`Unknown option: ${argument}`);
+  }
+  const positional = args.filter((argument) => !argument.startsWith("-"));
+  if (positional.length > 1) throw new Error("Expected one command. Run codex-tags --help for usage.");
+  const command = args.some((argument) => ["--help", "-h"].includes(argument)) ? "help"
+    : args.some((argument) => ["--version", "-v"].includes(argument)) ? "version"
+      : positional[0] ?? "install";
+  if (!commands.has(command)) throw new Error(`Unknown command: ${command}`);
+  const purge = args.includes("--purge");
+  if (purge && command !== "uninstall") throw new Error("--purge is only supported with uninstall.");
+  return { command, purge, json: args.includes("--json") };
+}

package/scripts/health.mjs

@@ -0,0 +1,20 @@
+export function runtimeHealthChecks({ runtime = {}, plugin = {}, supervisor = {} }) {
+  const versions = runtime.activeVersions;
+  return [
+    { id: "runtime-installed", ok: runtime.installed === true, message: "Local runtime installed" },
+    { id: "legacy-supervisor-stopped", ok: supervisor.loaded !== true, message: "No automatic app takeover running" },
+    { id: "plugin-installed", ok: plugin.installed === true && plugin.enabled === true && plugin.payloadPresent === true && !plugin.error, message: "Plugin installed and enabled" },
+    { id: "cdp", ok: runtime.cdp === true, message: "Owned loopback connection active" },
+    { id: "controller", ok: Number.isSafeInteger(runtime.controllerPid) && runtime.controllerPid > 0 && !runtime.error, message: "Local controller running" },
+    { id: "injected", ok: typeof runtime.sourceVersion === "string" && Array.isArray(versions) && versions.length > 0 && versions.every((version) => version === runtime.sourceVersion), message: "Current Tags UI loaded in every discovered window" },
+    { id: "settings", ok: Array.isArray(runtime.tagSettings?.tags) && !runtime.tagSettingsError, message: "Tag settings readable" },
+    { id: "search", ok: Number.isInteger(runtime.searchIndex?.indexedSessions) && !runtime.searchIndex?.error, message: "Local search index readable" },
+    { id: "catalog", ok: runtime.catalog?.complete === true && !runtime.catalog?.error, message: "Active local session catalog readable" },
+    { id: "sidebar", ok: Array.isArray(runtime.activeWindows) && runtime.activeWindows.some((window) => window?.toolbar === true), message: "Tags navigation available" },
+  ];
+}
+
+export function activationHealth(status) {
+  const checks = runtimeHealthChecks(status);
+  return { ok: checks.every(({ ok }) => ok), checks, hookAuthorization: "Review and enable all three Codex Tags hooks in Codex Plugins. CLI does not verify or grant hook trust." };
+}

package/scripts/lifecycle-lock.mjs

@@ -0,0 +1,21 @@
+import { lstat, mkdir, open, rm } from "node:fs/promises";
+
+export async function withLifecycleLock(directory, operation) {
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  if ((await lstat(directory)).isSymbolicLink()) throw new Error("Installation directory must not be a symbolic link.");
+  const path = `${directory}/.lifecycle.lock`;
+  let handle;
+  try {
+    handle = await open(path, "wx", 0o600);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    throw new Error(`Another installation may be running. Wait for it to finish. If it crashed, remove only ${path} after confirming no Codex Tags CLI is running.`);
+  }
+  try {
+    await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
+    return await operation();
+  } finally {
+    await handle.close();
+    await rm(path, { force: true });
+  }
+}

package/scripts/manage.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { basename } from "node:path";
+
+import { createManager } from "./manager-core.mjs";
+
+const manager = createManager();
+const command = process.argv[2] ?? "status";
+let result;
+
+if (command === "install") result = await manager.installRuntime();
+else if (command === "status") result = await manager.status();
+else if (command === "enable" || command === "on" || command === "update") result = await manager.enable();
+else if (command === "apply") result = await manager.runController("apply");
+else if (command === "restore" || command === "disable" || command === "off") result = await manager.disable();
+else if (command === "doctor") result = await manager.doctor();
+else if (command === "uninstall") result = await manager.uninstall({ purge: process.argv.includes("--purge") });
+else throw new Error(`Unknown command: ${basename(command)}`);
+
+console.log(JSON.stringify(result, null, 2));