@otto-code/server 0.5.0

package/dist/server/services/quota-fetcher/service.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "./provider.js";
+export interface ProviderUsageServiceOptions {
+    logger: Logger;
+    fetchers?: ProviderUsageFetcher[];
+    fetch?: ProviderApiFetch;
+    cacheTtlMs?: number;
+    now?: () => number;
+}
+export interface ProviderUsageListResult {
+    fetchedAt: string;
+    providers: ProviderUsage[];
+}
+export declare class ProviderUsageService {
+    private readonly logger;
+    private readonly fetchers;
+    private readonly cacheTtlMs;
+    private readonly now;
+    private cached;
+    private inFlight;
+    constructor(options: ProviderUsageServiceOptions);
+    listUsage(options?: {
+        forceRefresh?: boolean;
+    }): Promise<ProviderUsageListResult>;
+    private fetchFreshUsage;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/server/services/quota-fetcher/service.js

@@ -0,0 +1,58 @@
+import { createProviderUsageFetchers } from "./manifest.js";
+import { unavailableUsage } from "./usage.js";
+const DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS = 5 * 60 * 1000;
+export class ProviderUsageService {
+    constructor(options) {
+        this.cached = null;
+        this.inFlight = null;
+        this.logger = options.logger.child({ module: "provider-usage-service" });
+        this.fetchers =
+            options.fetchers ??
+                createProviderUsageFetchers({
+                    logger: this.logger,
+                    fetch: options.fetch,
+                });
+        this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    async listUsage(options) {
+        const nowMs = this.now();
+        if (!options?.forceRefresh &&
+            this.cached &&
+            nowMs - this.cached.fetchedAtMs < this.cacheTtlMs) {
+            return this.cached.result;
+        }
+        if (this.inFlight) {
+            return this.inFlight;
+        }
+        const request = this.fetchFreshUsage(nowMs);
+        this.inFlight = request;
+        try {
+            return await request;
+        }
+        finally {
+            if (this.inFlight === request) {
+                this.inFlight = null;
+            }
+        }
+    }
+    async fetchFreshUsage(nowMs) {
+        const settled = await Promise.allSettled(this.fetchers.map((fetcher) => fetcher.fetchUsage()));
+        const providers = settled.map((result, index) => {
+            const fetcher = this.fetchers[index];
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            this.logger.debug({ err: result.reason, providerId: fetcher.providerId }, "Provider usage fetch failed");
+            return unavailableUsage({
+                providerId: fetcher.providerId,
+                displayName: fetcher.displayName,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+        });
+        const result = { fetchedAt: new Date(nowMs).toISOString(), providers };
+        this.cached = { fetchedAtMs: nowMs, result };
+        return result;
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/server/services/quota-fetcher/usage.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { ProviderUsage, ProviderUsageBalance, ProviderUsageWindow } from "../../server/messages.js";
+import type { ProviderApiFetch } from "./provider.js";
+export declare const ApiNumberSchema: z.ZodCoercedNumber<unknown>;
+export declare const ApiNullableNumberSchema: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+export declare const ApiOptionalStringSchema: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedString<unknown>>>;
+export declare function fetchProviderApi(fetchApi: ProviderApiFetch, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function unavailableUsage(provider: {
+    providerId: string;
+    displayName: string;
+    error?: string | null;
+}): ProviderUsage;
+export declare function windowFromUsedPct(input: {
+    id: string;
+    label: string;
+    utilizationPct: number | null | undefined;
+    resetsAt?: string | null;
+    tone?: ProviderUsageWindow["tone"];
+}): ProviderUsageWindow;
+export declare function balanceToneFromRemaining(remaining: number | null | undefined): ProviderUsageBalance["tone"];
+export declare function toIsoStringOrNull(timestampMs: number): string | null;
+//# sourceMappingURL=usage.d.ts.map

package/dist/server/services/quota-fetcher/usage.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+const PROVIDER_HTTP_TIMEOUT_MS = 15000;
+export const ApiNumberSchema = z.coerce.number().finite();
+export const ApiNullableNumberSchema = z.preprocess((value) => (value == null ? null : value), ApiNumberSchema.nullable());
+export const ApiOptionalStringSchema = z.preprocess((value) => (value == null ? undefined : value), z.coerce.string().optional());
+export function fetchProviderApi(fetchApi, input, init = {}) {
+    return fetchApi(input, {
+        ...init,
+        signal: init.signal ?? AbortSignal.timeout(PROVIDER_HTTP_TIMEOUT_MS),
+    });
+}
+export function unavailableUsage(provider) {
+    return {
+        providerId: provider.providerId,
+        displayName: provider.displayName,
+        status: provider.error ? "error" : "unavailable",
+        planLabel: null,
+        windows: [],
+        balances: [],
+        details: [],
+        error: provider.error ?? null,
+    };
+}
+export function windowFromUsedPct(input) {
+    const usedPct = typeof input.utilizationPct === "number" ? input.utilizationPct : null;
+    const window = {
+        id: input.id,
+        label: input.label,
+        usedPct,
+        remainingPct: usedPct === null ? null : Math.max(0, 100 - usedPct),
+        resetsAt: input.resetsAt ?? null,
+    };
+    if (input.tone) {
+        window.tone = input.tone;
+    }
+    return window;
+}
+export function balanceToneFromRemaining(remaining) {
+    if (typeof remaining !== "number")
+        return "default";
+    if (remaining <= 0)
+        return "danger";
+    return "ok";
+}
+export function toIsoStringOrNull(timestampMs) {
+    const date = new Date(timestampMs);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+//# sourceMappingURL=usage.js.map

package/dist/server/terminal/activity/terminal-activity-tracker.d.ts

@@ -0,0 +1,20 @@
+import type { TerminalActivityAttentionReason, TerminalActivityState } from "@otto-code/protocol/terminal-activity";
+export interface TerminalActivitySnapshot {
+    state: TerminalActivityState | null;
+    attentionReason: TerminalActivityAttentionReason | null;
+    changedAt: number;
+}
+export declare class TerminalActivityTracker {
+    private resolvedState;
+    private attentionReason;
+    private changedAt;
+    private readonly changeListeners;
+    set(state: TerminalActivityState): void;
+    clear(): void;
+    clearAttention(): boolean;
+    private setState;
+    onChange(listener: (snapshot: TerminalActivitySnapshot, previous: TerminalActivitySnapshot) => void): () => void;
+    getSnapshot(): TerminalActivitySnapshot;
+    dispose(): void;
+}
+//# sourceMappingURL=terminal-activity-tracker.d.ts.map

package/dist/server/terminal/activity/terminal-activity-tracker.js

@@ -0,0 +1,59 @@
+export class TerminalActivityTracker {
+    constructor() {
+        // unknown != idle: a plain shell, or a terminal whose agent was killed, has no dot or rollup.
+        this.resolvedState = null;
+        this.attentionReason = null;
+        this.changedAt = Date.now();
+        this.changeListeners = new Set();
+    }
+    set(state) {
+        if (state === "idle" && this.resolvedState === "working") {
+            this.setState("idle", "finished");
+            return;
+        }
+        if (state === "idle" && this.attentionReason === "finished") {
+            return;
+        }
+        this.setState(state === "attention" ? "idle" : state, state === "attention" ? "needs_input" : null);
+    }
+    clear() {
+        this.setState(null, null);
+    }
+    clearAttention() {
+        if (!this.attentionReason) {
+            return false;
+        }
+        this.setState("idle", null);
+        return true;
+    }
+    setState(state, attentionReason) {
+        if (state === this.resolvedState && attentionReason === this.attentionReason) {
+            return;
+        }
+        const previous = this.getSnapshot();
+        this.resolvedState = state;
+        this.attentionReason = attentionReason;
+        this.changedAt = Date.now();
+        const snapshot = this.getSnapshot();
+        for (const listener of Array.from(this.changeListeners)) {
+            listener(snapshot, previous);
+        }
+    }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    getSnapshot() {
+        return {
+            state: this.resolvedState,
+            attentionReason: this.attentionReason,
+            changedAt: this.changedAt,
+        };
+    }
+    dispose() {
+        this.changeListeners.clear();
+    }
+}
+//# sourceMappingURL=terminal-activity-tracker.js.map

package/dist/server/terminal/agent-hooks/agent-hook-installer.d.ts

@@ -0,0 +1,62 @@
+export interface AgentHookEventDefinition {
+    event: string;
+}
+export type AgentHookActivityState = "running" | "idle" | "needs-input";
+export interface AgentHookActivityInput {
+    isTTY?: boolean;
+    read(): Promise<string | null>;
+}
+export interface AgentHookProvider<TConfig = unknown> {
+    id: string;
+    events: AgentHookEventDefinition[];
+    resolveActivity(input: {
+        event: string;
+        input: AgentHookActivityInput;
+    }): Promise<AgentHookActivityState | null>;
+    install: AgentHookInstallStrategy<TConfig>;
+}
+export type AgentHookInstallStrategy<TConfig> = AgentHookConfigFileInstallStrategy<TConfig> | AgentHookPluginFileInstallStrategy;
+interface AgentHookInstallStrategyBase {
+    kind: "config-file" | "plugin-file";
+    configDir: string;
+    configDirBase?: "home" | "xdg-config";
+    configFile: string;
+    configDirEnvOverride?: string;
+    hookMarker: string;
+}
+export interface AgentHookConfigFileInstallStrategy<TConfig> extends AgentHookInstallStrategyBase {
+    kind: "config-file";
+    format: AgentHookConfigFormat<TConfig>;
+}
+export interface AgentHookPluginFileInstallStrategy extends AgentHookInstallStrategyBase {
+    kind: "plugin-file";
+    source: string;
+}
+export interface AgentHookConfigFormat<TConfig> {
+    empty(): TConfig;
+    parse(raw: string): TConfig;
+    stringify(config: TConfig): string;
+    install(config: TConfig, provider: AgentHookProvider<TConfig>): TConfig;
+    uninstall(config: TConfig, provider: AgentHookProvider<TConfig>): TConfig;
+    isInstalled(config: TConfig, provider: AgentHookProvider<TConfig>): boolean;
+}
+export interface AgentHookInstallOptions {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    configDir?: string;
+}
+export interface AgentHookInstallLogger {
+    warn(bindings: Record<string, unknown>, message: string): void;
+}
+export interface AgentHookInstallResult {
+    configPath: string;
+    changed: boolean;
+}
+export declare function installAgentHooks<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): AgentHookInstallResult;
+export declare function uninstallAgentHooks<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): AgentHookInstallResult;
+export declare function agentHooksAreInstalled<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): boolean;
+export declare function resolveAgentHookConfigPath<TConfig>(provider: AgentHookProvider<TConfig>, options?: AgentHookInstallOptions): string;
+export declare function buildAgentHookShellCommand<TConfig>(provider: AgentHookProvider<TConfig>, event: AgentHookEventDefinition): string;
+export declare function buildAgentHookWindowsCommand<TConfig>(provider: AgentHookProvider<TConfig>, event: AgentHookEventDefinition): string;
+export {};
+//# sourceMappingURL=agent-hook-installer.d.ts.map

package/dist/server/terminal/agent-hooks/agent-hook-installer.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { writePrivateFileAtomicSync } from "../../server/private-files.js";
+export function installAgentHooks(provider, options = {}) {
+    if (provider.install.kind === "plugin-file") {
+        return installAgentHookPluginFile(provider.install, options);
+    }
+    const format = provider.install.format;
+    return updateAgentHookConfig(provider, options, (config) => format.install(config, provider));
+}
+export function uninstallAgentHooks(provider, options = {}) {
+    if (provider.install.kind === "plugin-file") {
+        return uninstallAgentHookPluginFile(provider.install, options);
+    }
+    const format = provider.install.format;
+    return updateAgentHookConfig(provider, options, (config) => format.uninstall(config, provider));
+}
+export function agentHooksAreInstalled(provider, options = {}) {
+    const configPath = resolveAgentHookConfigPath(provider, options);
+    if (!existsSync(configPath)) {
+        return false;
+    }
+    if (provider.install.kind === "plugin-file") {
+        const currentRaw = readFileSync(configPath, "utf8");
+        return normalizeRawConfig(currentRaw) === normalizeRawConfig(provider.install.source);
+    }
+    const config = provider.install.format.parse(readFileSync(configPath, "utf8"));
+    return provider.install.format.isInstalled(config, provider);
+}
+export function resolveAgentHookConfigPath(provider, options = {}) {
+    return resolveAgentHookInstallPath(provider.install, options);
+}
+function resolveAgentHookInstallPath(install, options) {
+    const configDir = options.configDir ??
+        resolveConfiguredDirectory({
+            install,
+            env: options.env ?? process.env,
+            homeDir: options.homeDir ?? homedir(),
+        });
+    return path.join(configDir, install.configFile);
+}
+export function buildAgentHookShellCommand(provider, event) {
+    const hookCommand = `"\${OTTO_HOOK_CLI:-otto}" hooks ${shellToken(provider.id)} ${shellToken(event.event)}`;
+    return `if [ -n "$OTTO_TERMINAL_ID" ]; then ${hookCommand}; fi`;
+}
+export function buildAgentHookWindowsCommand(provider, event) {
+    const hookArgs = `hooks ${windowsToken(provider.id)} ${windowsToken(event.event)}`;
+    return `if defined OTTO_TERMINAL_ID (if defined OTTO_HOOK_CLI ("%OTTO_HOOK_CLI%" ${hookArgs}) else (otto ${hookArgs})) else (exit /b 0)`;
+}
+function installAgentHookPluginFile(install, options) {
+    const configPath = resolveAgentHookInstallPath(install, options);
+    const currentRaw = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const nextRaw = normalizeRawConfig(install.source);
+    if (currentRaw === null || normalizeRawConfig(currentRaw) !== nextRaw) {
+        writePrivateFileAtomicSync(configPath, nextRaw);
+        return { configPath, changed: true };
+    }
+    return { configPath, changed: false };
+}
+function uninstallAgentHookPluginFile(install, options) {
+    const configPath = resolveAgentHookInstallPath(install, options);
+    if (!existsSync(configPath)) {
+        return { configPath, changed: false };
+    }
+    rmSync(configPath, { force: true });
+    return { configPath, changed: true };
+}
+function updateAgentHookConfig(provider, options, update) {
+    const install = provider.install;
+    if (install.kind !== "config-file") {
+        throw new Error(`Provider ${provider.id} does not use config-file hooks`);
+    }
+    const configPath = resolveAgentHookConfigPath(provider, options);
+    const currentRaw = existsSync(configPath) ? readFileSync(configPath, "utf8") : null;
+    const currentConfig = currentRaw === null ? install.format.empty() : install.format.parse(currentRaw);
+    const nextConfig = update(currentConfig);
+    const nextRaw = install.format.stringify(nextConfig);
+    if (currentRaw === null || nextRaw !== normalizeRawConfig(currentRaw)) {
+        writePrivateFileAtomicSync(configPath, nextRaw);
+        return { configPath, changed: true };
+    }
+    return { configPath, changed: false };
+}
+function resolveConfiguredDirectory(input) {
+    const overrideName = input.install.configDirEnvOverride;
+    const override = overrideName ? input.env[overrideName] : undefined;
+    if (override) {
+        return override;
+    }
+    if (input.install.configDirBase === "xdg-config") {
+        return path.join(resolveXdgConfigHome(input), input.install.configDir);
+    }
+    return path.join(input.homeDir, input.install.configDir);
+}
+function resolveXdgConfigHome(input) {
+    if (input.env.XDG_CONFIG_HOME) {
+        return input.env.XDG_CONFIG_HOME;
+    }
+    return path.join(input.homeDir, ".config");
+}
+function normalizeRawConfig(raw) {
+    return raw.endsWith("\n") ? raw : `${raw}\n`;
+}
+function shellToken(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function windowsToken(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll('"', '\\"')}"`;
+}
+//# sourceMappingURL=agent-hook-installer.js.map

package/dist/server/terminal/agent-hooks/claude/claude-settings.d.ts

@@ -0,0 +1,7 @@
+import { type AgentHookConfigFormat } from "../agent-hook-installer.js";
+export interface ClaudeSettings {
+    hooks?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare const claudeSettingsFormat: AgentHookConfigFormat<ClaudeSettings>;
+//# sourceMappingURL=claude-settings.d.ts.map

package/dist/server/terminal/agent-hooks/claude/claude-settings.js

@@ -0,0 +1,88 @@
+import { buildAgentHookShellCommand } from "../agent-hook-installer.js";
+export const claudeSettingsFormat = {
+    empty() {
+        return {};
+    },
+    parse(raw) {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {};
+        }
+        return parsed;
+    },
+    stringify(config) {
+        return `${JSON.stringify(config, null, 2)}\n`;
+    },
+    install(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const userEntries = removeOttoHooks(hooks[event.event], install.hookMarker);
+            hooks[event.event] = [
+                ...userEntries,
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildAgentHookShellCommand(provider, event),
+                            timeout: 10,
+                        },
+                    ],
+                },
+            ];
+        }
+        return { ...config, hooks };
+    },
+    uninstall(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const entries = removeOttoHooks(hooks[event.event], install.hookMarker);
+            if (entries.length > 0) {
+                hooks[event.event] = entries;
+            }
+            else {
+                delete hooks[event.event];
+            }
+        }
+        return { ...config, hooks };
+    },
+    isInstalled(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        return provider.events.every((event) => normalizeMatchers(hooks[event.event]).some((entry) => normalizeCommandHooks(entry.hooks).some((hook) => commandContainsMarker(hook, install.hookMarker))));
+    },
+};
+function normalizeHooks(value) {
+    return isRecord(value) ? { ...value } : {};
+}
+function normalizeMatchers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function normalizeCommandHooks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function removeOttoHooks(value, marker) {
+    const entries = [];
+    for (const entry of normalizeMatchers(value)) {
+        const hooks = normalizeCommandHooks(entry.hooks).filter((hook) => !commandContainsMarker(hook, marker));
+        if (hooks.length > 0) {
+            entries.push(Object.assign({}, entry, { hooks }));
+        }
+    }
+    return entries;
+}
+function commandContainsMarker(hook, marker) {
+    return typeof hook.command === "string" && hook.command.includes(marker);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=claude-settings.js.map

package/dist/server/terminal/agent-hooks/claude/claude.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+import { type ClaudeSettings } from "./claude-settings.js";
+export declare const claudeAgentHookProvider: AgentHookProvider<ClaudeSettings>;
+//# sourceMappingURL=claude.d.ts.map

package/dist/server/terminal/agent-hooks/claude/claude.js

@@ -0,0 +1,47 @@
+import { claudeSettingsFormat } from "./claude-settings.js";
+const CLAUDE_EVENT_STATES = {
+    UserPromptSubmit: "running",
+    Stop: "idle",
+    StopFailure: "idle",
+    SessionEnd: "idle",
+};
+export const claudeAgentHookProvider = {
+    id: "claude",
+    events: [
+        { event: "UserPromptSubmit" },
+        { event: "Stop" },
+        { event: "StopFailure" },
+        { event: "SessionEnd" },
+        { event: "Notification" },
+    ],
+    install: {
+        kind: "config-file",
+        configDir: ".claude",
+        configFile: "settings.json",
+        configDirEnvOverride: "CLAUDE_CONFIG_DIR",
+        hookMarker: "hooks claude",
+        format: claudeSettingsFormat,
+    },
+    async resolveActivity({ event, input }) {
+        if (event === "Notification") {
+            const raw = input.isTTY ? null : await input.read();
+            return isIdlePrompt(raw) ? "needs-input" : null;
+        }
+        return CLAUDE_EVENT_STATES[event] ?? null;
+    },
+};
+function isIdlePrompt(raw) {
+    if (!raw)
+        return false;
+    try {
+        const notification = JSON.parse(raw);
+        if (!notification || typeof notification !== "object")
+            return false;
+        const payload = notification;
+        return payload.matcher === "idle_prompt" || payload.reason === "idle_prompt";
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/server/terminal/agent-hooks/codex/codex-settings.d.ts

@@ -0,0 +1,7 @@
+import { type AgentHookConfigFormat } from "../agent-hook-installer.js";
+export interface CodexHooksFile {
+    hooks?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare const codexHooksFormat: AgentHookConfigFormat<CodexHooksFile>;
+//# sourceMappingURL=codex-settings.d.ts.map

package/dist/server/terminal/agent-hooks/codex/codex-settings.js

@@ -0,0 +1,99 @@
+import { buildAgentHookShellCommand, buildAgentHookWindowsCommand, } from "../agent-hook-installer.js";
+export const codexHooksFormat = {
+    empty() {
+        return {};
+    },
+    parse(raw) {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed)) {
+            return {};
+        }
+        return parsed;
+    },
+    stringify(config) {
+        return `${JSON.stringify(config, null, 2)}\n`;
+    },
+    install(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const userEntries = removeOttoHooks(hooks[event.event], install.hookMarker);
+            hooks[event.event] = [
+                ...userEntries,
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildAgentHookShellCommand(provider, event),
+                            commandWindows: buildAgentHookWindowsCommand(provider, event),
+                            timeout: 10,
+                        },
+                    ],
+                },
+            ];
+        }
+        return { ...config, hooks };
+    },
+    uninstall(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        for (const event of provider.events) {
+            const entries = removeOttoHooks(hooks[event.event], install.hookMarker);
+            if (entries.length > 0) {
+                hooks[event.event] = entries;
+            }
+            else {
+                delete hooks[event.event];
+            }
+        }
+        return { ...config, hooks };
+    },
+    isInstalled(config, provider) {
+        const install = provider.install;
+        const hooks = normalizeHooks(config.hooks);
+        return provider.events.every((event) => normalizeMatchers(hooks[event.event]).some((entry) => normalizeCommandHooks(entry.hooks).some((hook) => hasOttoCommands(hook, install.hookMarker))));
+    },
+};
+function normalizeHooks(value) {
+    return isRecord(value) ? { ...value } : {};
+}
+function normalizeMatchers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function normalizeCommandHooks(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function removeOttoHooks(value, marker) {
+    const entries = [];
+    for (const entry of normalizeMatchers(value)) {
+        const hooks = normalizeCommandHooks(entry.hooks).filter((hook) => !commandContainsMarker(hook, marker));
+        if (hooks.length > 0) {
+            entries.push(Object.assign({}, entry, { hooks }));
+        }
+    }
+    return entries;
+}
+function hasOttoCommands(hook, marker) {
+    return (commandFieldContainsMarker(hook.command, marker) && windowsCommandContainsMarker(hook, marker));
+}
+function commandContainsMarker(hook, marker) {
+    return (commandFieldContainsMarker(hook.command, marker) || windowsCommandContainsMarker(hook, marker));
+}
+function windowsCommandContainsMarker(hook, marker) {
+    return (commandFieldContainsMarker(hook.commandWindows, marker) ||
+        commandFieldContainsMarker(hook.command_windows, marker));
+}
+function commandFieldContainsMarker(value, marker) {
+    return typeof value === "string" && value.includes(marker);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=codex-settings.js.map