@blastin-dev/clocktopus-cli 0.1.4 → 0.2.1

package/dist/src/lib/agent-config.js

@@ -0,0 +1,168 @@
+import { accessSync, constants, existsSync, readFileSync, realpathSync, } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { readInstalledTelemetry, settingsPath } from "./claude-settings.js";
+import { codexConfigPath, readCodexTelemetry } from "./codex-config.js";
+import { opencodePluginPath, readOpencodePlugin } from "./opencode-config.js";
+export function resolveAgentCredentials(agent = "claude") {
+    const envToken = process.env.CLOCKTOPUS_INGEST_TOKEN?.trim();
+    const envEndpoint = process.env.CLOCKTOPUS_OTEL_ENDPOINT?.trim();
+    let fileToken;
+    let fileEndpoint;
+    try {
+        if (agent === "codex") {
+            const codex = readCodexTelemetry();
+            fileToken = codex.token ?? undefined;
+            fileEndpoint = codex.endpoint ?? undefined;
+        }
+        else if (agent === "opencode") {
+            const plugin = readOpencodePlugin();
+            fileToken = plugin.config?.token ?? undefined;
+            fileEndpoint = plugin.config?.endpoint ?? undefined;
+        }
+        else {
+            const installed = readInstalledTelemetry();
+            fileToken = installed.env.CLOCKTOPUS_INGEST_TOKEN;
+            fileEndpoint = installed.env.CLOCKTOPUS_OTEL_ENDPOINT;
+        }
+    }
+    catch {
+        // A malformed config file is reported properly by `setup` and `doctor`.
+        // Credential resolution must not throw — the hook calls it on every
+        // session start.
+    }
+    return {
+        token: envToken || fileToken || null,
+        endpoint: (envEndpoint || fileEndpoint || null)?.replace(/\/$/, "") ?? null,
+        tokenSource: envToken ? "environment" : fileToken ? "settings" : "none",
+        endpointSource: envEndpoint
+            ? "environment"
+            : fileEndpoint
+                ? "settings"
+                : "none",
+        sourcePath: agent === "codex"
+            ? codexConfigPath()
+            : agent === "opencode"
+                ? opencodePluginPath()
+                : settingsPath(),
+    };
+}
+/** Masks a token for display: never print more than the stored prefix. */
+export function maskToken(token) {
+    return token.length <= 15 ? "…" : `${token.slice(0, 15)}…`;
+}
+/**
+ * Files that commonly export the same variables, and would be shadowed.
+ *
+ * Scanned rather than guessed at, because "your `.envrc` is being ignored"
+ * is only useful advice when it names the file. The repo-local `.envrc` is
+ * included because that is exactly how this project was dogfooded before
+ * the CLI existed.
+ */
+const SHELL_FILES = [
+    ".bashrc",
+    ".bash_profile",
+    ".zshrc",
+    ".zshenv",
+    ".profile",
+    ".config/fish/config.fish",
+];
+export function findShadowedExports(cwd = process.cwd()) {
+    const candidates = [
+        ...SHELL_FILES.map((file) => join(homedir(), file)),
+        join(cwd, ".envrc"),
+    ];
+    const found = [];
+    for (const path of candidates) {
+        let contents;
+        try {
+            if (!existsSync(path))
+                continue;
+            contents = readFileSync(path, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const keys = [
+            "CLOCKTOPUS_INGEST_TOKEN",
+            "CLOCKTOPUS_OTEL_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_HEADERS",
+            "CLAUDE_CODE_ENABLE_TELEMETRY",
+        ].filter((key) => new RegExp(`^\\s*(export\\s+)?${key}=`, "m").test(contents));
+        if (keys.length > 0)
+            found.push({ path, keys });
+    }
+    return found;
+}
+/**
+ * The command to write into an agent's hook configuration.
+ *
+ * Prefers the bare name, but only after confirming that `clocktopus` on
+ * PATH resolves to *this* executable. Hooks run through a shell whose PATH
+ * may differ from the interactive one, and a bare name that does not
+ * resolve there fails silently — the session runs fine and every bit of
+ * repository context is lost. An absolute path is uglier and survives that;
+ * `doctor` checks it still exists.
+ *
+ * The provider is baked into the command because the two agents send
+ * *identical* hook payloads — same field names, same event spellings, no
+ * marker of any kind. Which agent is calling can only be known from how the
+ * hook was installed.
+ */
+export function resolveHookCommand(provider) {
+    const script = process.argv[1] ? resolve(process.argv[1]) : null;
+    const quote = (value) => /[\s"']/.test(value) ? `"${value}"` : value;
+    const args = `agent hook --provider ${provider}`;
+    if (script && resolvesOnPath("clocktopus", script)) {
+        return {
+            command: `clocktopus ${args}`,
+            usesAbsolutePath: false,
+            binaryPath: script,
+        };
+    }
+    if (script) {
+        // `node <script>` rather than executing the script directly: the file in
+        // a published package keeps its shebang, but a checkout may not have the
+        // executable bit, and the hook must not depend on that.
+        return {
+            command: `${quote(process.execPath)} ${quote(script)} ${args}`,
+            usesAbsolutePath: true,
+            binaryPath: script,
+        };
+    }
+    return {
+        command: `clocktopus ${args}`,
+        usesAbsolutePath: false,
+        binaryPath: null,
+    };
+}
+function resolvesOnPath(name, expected) {
+    const searchPath = process.env.PATH;
+    if (!searchPath)
+        return false;
+    let expectedReal;
+    try {
+        expectedReal = realpathSync(expected);
+    }
+    catch {
+        return false;
+    }
+    for (const dir of searchPath.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        try {
+            accessSync(candidate, constants.X_OK);
+            if (realpathSync(candidate) === expectedReal)
+                return true;
+            // A different `clocktopus` earlier on PATH would shadow this one, so
+            // stop rather than keep looking for a match further down.
+            return false;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}

package/dist/src/lib/agent-hook-state.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+declare const LastRunSchema: z.ZodObject<{
+    at: z.ZodString;
+    event: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    tokenPrefix: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    repository: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HookLastRun = z.infer<typeof LastRunSchema>;
+declare const StartStateSchema: z.ZodObject<{
+    sha: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    closed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type HookStartState = z.infer<typeof StartStateSchema>;
+export declare function writeStartState(sessionId: string, state: {
+    sha: string;
+    cwd: string;
+    provider: string;
+    closed?: boolean;
+}): void;
+export declare function readStartState(sessionId: string): HookStartState | undefined;
+export declare function clearStartState(sessionId: string): void;
+export declare function listStartStates(): Array<{
+    sessionId: string;
+    ageMs: number;
+    /**
+     * When the state file was last touched — the newest moment this machine
+     * has evidence the session existed. The sweep sends it as the abandoned
+     * session's `ended_at` so the receiver does not stamp its own clock,
+     * hours later, as the end of a window used to attribute commits.
+     */
+    lastActivityAt: Date;
+}>;
+export declare function recordLastRun(run: HookLastRun): void;
+export declare function readLastRun(): HookLastRun | null;
+export declare function clearHookState(): void;
+export {};
+//# sourceMappingURL=agent-hook-state.d.ts.map

package/dist/src/lib/agent-hook-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-hook-state.d.ts","sourceRoot":"","sources":["../../../src/lib/agent-hook-state.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,QAAA,MAAM,aAAa;;;;;;;;;;iBAYjB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAExD,QAAA,MAAM,gBAAgB;;;;;iBAoBpB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAK9D,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GACtE,IAAI,CAWN;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAgB5E;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAMvD;AAED,wBAAgB,eAAe,IAAI,KAAK,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,cAAc,EAAE,IAAI,CAAC;CACtB,CAAC,CAsBD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAOpD;AAED,wBAAgB,WAAW,IAAI,WAAW,GAAG,IAAI,CAShD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAOrC"}

package/dist/src/lib/agent-hook-state.js

@@ -0,0 +1,155 @@
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+/**
+ * On-disk state the SessionStart/SessionEnd hook keeps between its two
+ * invocations, plus the record of what the last invocation achieved.
+ *
+ * Under the cache directory rather than the repository so it never shows up
+ * in `git status`. The path is unchanged from the standalone script this
+ * command replaced (`scripts/agent-telemetry/claude-hook.mjs`, since
+ * deleted) on purpose: a session that started under the old script must
+ * still be able to close under the new one, and a sweep must still find
+ * what the old one abandoned.
+ */
+const CACHE_DIR = join(homedir(), ".cache", "clocktopus");
+const STATE_DIR = join(CACHE_DIR, "agent-sessions");
+/**
+ * The hook's last outcome, written every run.
+ *
+ * This is the only place the pipeline reports on itself from the machine's
+ * own side. The hook must stay silent — it cannot warn, prompt or print —
+ * so instead it leaves a receipt, and `agent status` / `agent doctor` read
+ * it. Without this, a token that started returning 401 mid-week is
+ * invisible locally: the session runs normally and nothing is written
+ * anywhere the user looks.
+ */
+const LAST_RUN_FILE = join(CACHE_DIR, "agent-hook-last.json");
+const LastRunSchema = z.object({
+    at: z.string(),
+    event: z.string().optional(),
+    /** Which agent's hook ran — one receipt file is shared by all of them. */
+    provider: z.string().optional(),
+    sessionId: z.string().optional(),
+    endpoint: z.string().optional(),
+    tokenPrefix: z.string().optional(),
+    /** HTTP status from the receiver, or null when the request never landed. */
+    status: z.number().nullable().optional(),
+    error: z.string().nullable().optional(),
+    repository: z.string().nullable().optional(),
+});
+const StartStateSchema = z.object({
+    sha: z.string(),
+    cwd: z.string().optional(),
+    /**
+     * The agent that opened this session.
+     *
+     * Recorded because the sweep runs from whichever agent starts *next*, and
+     * closing a Codex session as `claude_code` would not close it at all — it
+     * would open a second, empty session row under the wrong provider and
+     * leave the real one hanging forever.
+     */
+    provider: z.string().optional(),
+    /**
+     * Set once the session has had a real SessionEnd, and kept only because
+     * its host can send another one — see `hostRepeatsSessionEnd`. The file
+     * still holds the starting SHA the next SessionEnd needs to diff against,
+     * but the session is already closed in the database, so the sweep must
+     * delete it rather than close it a second time with a stale HEAD.
+     */
+    closed: z.boolean().optional(),
+});
+const stateFile = (sessionId) => join(STATE_DIR, `${sessionId.replace(/[^\w-]/g, "")}.sha`);
+export function writeStartState(sessionId, state) {
+    try {
+        mkdirSync(STATE_DIR, { recursive: true });
+        // `cwd` is stored alongside the SHA because the sweep runs from
+        // whatever repository the *next* session happens to start in.
+        // Resolving an abandoned session's SHA against the wrong checkout would
+        // either fail or, worse, succeed against an unrelated history.
+        writeFileSync(stateFile(sessionId), JSON.stringify(state), "utf8");
+    }
+    catch {
+        // Losing the start SHA costs the exact commit list, not the session.
+    }
+}
+export function readStartState(sessionId) {
+    try {
+        const raw = readFileSync(stateFile(sessionId), "utf8").trim();
+        if (!raw)
+            return undefined;
+        try {
+            const parsed = StartStateSchema.safeParse(JSON.parse(raw));
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch {
+            // Files written by earlier versions hold a bare SHA. A session that
+            // started under the old format must still close correctly.
+            return { sha: raw };
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function clearStartState(sessionId) {
+    try {
+        rmSync(stateFile(sessionId), { force: true });
+    }
+    catch {
+        // Best effort; a stale file is overwritten by the next session anyway.
+    }
+}
+export function listStartStates() {
+    try {
+        const now = Date.now();
+        return readdirSync(STATE_DIR)
+            .filter((name) => name.endsWith(".sha"))
+            .flatMap((name) => {
+            try {
+                const { mtimeMs } = statSync(join(STATE_DIR, name));
+                return [
+                    {
+                        sessionId: name.replace(/\.sha$/, ""),
+                        ageMs: now - mtimeMs,
+                        lastActivityAt: new Date(mtimeMs),
+                    },
+                ];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function recordLastRun(run) {
+    try {
+        mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(LAST_RUN_FILE, JSON.stringify(run, null, 2), "utf8");
+    }
+    catch {
+        // A missing receipt degrades diagnostics; it must never fail a session.
+    }
+}
+export function readLastRun() {
+    try {
+        const parsed = LastRunSchema.safeParse(JSON.parse(readFileSync(LAST_RUN_FILE, "utf8")));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function clearHookState() {
+    try {
+        rmSync(STATE_DIR, { recursive: true, force: true });
+        rmSync(LAST_RUN_FILE, { force: true });
+    }
+    catch {
+        // Nothing to clean up, or not ours to clean up.
+    }
+}

package/dist/src/lib/agent-receiver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Talks to the OTLP receiver directly, which is the whole point.
+ *
+ * The receiver is a different host from the web app — its own Router, its
+ * own Lambda, its own domain — so a token that works against the dashboard
+ * proves nothing about whether telemetry can reach ingest. This check is
+ * the only local way to tell "nothing has happened yet" apart from "nothing
+ * can happen": a wrong endpoint, a revoked token and an idle afternoon all
+ * look identical otherwise.
+ */
+export type ReceiverCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "invalid_token";
+} | {
+    ok: false;
+    reason: "unexpected_status";
+    status: number;
+} | {
+    ok: false;
+    reason: "unreachable";
+    message: string;
+};
+export declare function verifyReceiver(endpoint: string, token: string): Promise<ReceiverCheck>;
+//# sourceMappingURL=agent-receiver.d.ts.map

package/dist/src/lib/agent-receiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-receiver.d.ts","sourceRoot":"","sources":["../../../src/lib/agent-receiver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GACtC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,CAAC,CA+BxB"}

package/dist/src/lib/agent-receiver.js

@@ -0,0 +1,44 @@
+/**
+ * Talks to the OTLP receiver directly, which is the whole point.
+ *
+ * The receiver is a different host from the web app — its own Router, its
+ * own Lambda, its own domain — so a token that works against the dashboard
+ * proves nothing about whether telemetry can reach ingest. This check is
+ * the only local way to tell "nothing has happened yet" apart from "nothing
+ * can happen": a wrong endpoint, a revoked token and an idle afternoon all
+ * look identical otherwise.
+ */
+const TIMEOUT_MS = 8000;
+export async function verifyReceiver(endpoint, token) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const response = await fetch(`${endpoint.replace(/\/$/, "")}/v1/verify`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`,
+            },
+            body: "{}",
+            signal: controller.signal,
+        });
+        if (response.ok)
+            return { ok: true };
+        if (response.status === 401)
+            return { ok: false, reason: "invalid_token" };
+        // A 404 here is worth distinguishing in the caller's advice: it means the
+        // URL resolved to something that is not this receiver, or to a receiver
+        // deployed before /v1/verify existed.
+        return { ok: false, reason: "unexpected_status", status: response.status };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "unreachable",
+            message: error instanceof Error ? error.message : "request failed",
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/src/lib/agents.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The agents `clocktopus agent` can wire up, behind one interface.
+ *
+ * Everything agent-specific lives here: where the config is, how to detect
+ * an install, what "configured" means, and how to add or remove our half of
+ * it. `setup`, `status`, `doctor` and `disable` iterate this list, so
+ * adding a third agent is a new entry rather than a new branch in five
+ * commands.
+ *
+ * The two supported agents look similar and are not:
+ *
+ * |               | Claude Code                | Codex CLI                        |
+ * | ------------- | -------------------------- | -------------------------------- |
+ * | telemetry     | OTLP metrics, real dollars | OTLP **logs**, tokens only       |
+ * | config        | `settings.json` (one file) | `config.toml` + `hooks.json`     |
+ * | credentials   | env vars it injects        | read back out of `config.toml`   |
+ * | takes effect  | restart                    | restart **and** a trust prompt   |
+ *
+ * The credentials row is the subtle one. Claude Code applies `settings.json`
+ * `env` to the session, so our hook inherits the token from the process
+ * environment. Codex injects nothing, so the Codex hook has to read the
+ * token back out of `config.toml` — which is why `resolveAgentCredentials`
+ * takes a provider.
+ */
+export type AgentId = "claude" | "codex" | "opencode";
+/** How the ingested session is labelled — must match `AgentProvider` in core. */
+export type AgentProviderId = "claude_code" | "codex_cli" | "opencode";
+export type AgentTelemetryState = {
+    token: string | null;
+    endpoint: string | null;
+    /** Per-event, because a half-installed hook pair degrades silently. */
+    hookCommands: Partial<Record<"SessionStart" | "SessionEnd", string>>;
+    /** Newest mtime across the agent's config files, for the restart check. */
+    modifiedAt: Date | null;
+    /** Files we would write, whether or not they exist yet. */
+    paths: string[];
+};
+export type AgentAdapter = {
+    id: AgentId;
+    label: string;
+    provider: AgentProviderId;
+    /** Executable name, used both to detect an install and to name it in help. */
+    binary: string;
+    /**
+     * Whether the agent runs hooks off the session's critical path itself.
+     *
+     * Claude Code does, given `"async": true`. Codex does not — 0.147 skips
+     * an async SessionStart outright and 0.148 still forces SessionEnd
+     * synchronous — so its hooks omit the key and `agent hook` backgrounds
+     * itself instead. See the header of `commands/agent/hook.ts`.
+     */
+    hostRunsHooksAsync: boolean;
+    /**
+     * Whether the host can fire SessionEnd more than once for one session.
+     *
+     * Claude Code and Codex each end a session exactly once. OpenCode has no
+     * session-ended event at all — the plugin maps `session.idle` to
+     * SessionEnd, and that fires every time the agent stops and waits for a
+     * human, so a five-turn conversation sends five of them.
+     *
+     * The hook keeps its starting SHA in a state file keyed by session id and
+     * deletes it on SessionEnd. Deleting it after the first idle would leave
+     * every later turn with no range to diff, so nothing committed after the
+     * agent's first pause could ever be declared — see `commands/agent/hook.ts`.
+     */
+    hostRepeatsSessionEnd: boolean;
+    /** Files this agent's telemetry configuration lives in. */
+    paths(): string[];
+    read(): AgentTelemetryState;
+    apply(input: {
+        token: string;
+        endpoint: string;
+        hookCommand: string;
+    }): {
+        backupPaths: string[];
+    };
+    remove(): {
+        removed: string[];
+    };
+    /**
+     * Anything the user must still do by hand before telemetry flows.
+     * Empty when the agent is ready apart from a restart.
+     */
+    pendingActions(): string[];
+    /**
+     * Why the installed configuration is behind this CLI, or null when it is
+     * current. Only defined for agents whose integration is *generated
+     * source*, which is OpenCode alone: the others store a command string
+     * that means whatever the installed CLI means, so upgrading the CLI
+     * upgrades them and there is nothing to be behind.
+     */
+    staleReason?(): string | null;
+};
+/** `true` when the parse error is one of ours, whichever agent raised it. */
+export declare function isConfigParseError(error: unknown): error is Error;
+export declare const AGENTS: readonly AgentAdapter[];
+export type AgentSurvey = {
+    agent: AgentAdapter;
+    /** Version string when the binary is on PATH, `null` when it is not. */
+    version: string | null;
+    installed: boolean;
+    /** True once our token is written into this agent's config. */
+    configured: boolean;
+    /** Set when the agent's config exists but could not be parsed. */
+    unreadable: string | null;
+};
+/**
+ * What is on this machine, and what is already wired up.
+ *
+ * Detection is by `--version` rather than by config directory: `~/.claude`
+ * and `~/.codex` both outlive an uninstall, so a stale directory would
+ * offer to configure an agent that is no longer there.
+ */
+export declare function surveyAgents(): AgentSurvey[];
+//# sourceMappingURL=agents.d.ts.map

package/dist/src/lib/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/lib/agents.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;AAEtD,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,WAAW,GAAG,UAAU,CAAC;AAEvE,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,uEAAuE;IACvE,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,GAAG,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IACrE,2EAA2E;IAC3E,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,CAAC;IAC1B,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAC/B,2DAA2D;IAC3D,KAAK,IAAI,MAAM,EAAE,CAAC;IAClB,IAAI,IAAI,mBAAmB,CAAC;IAC5B,KAAK,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG;QACtE,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;IACF,MAAM,IAAI;QAAE,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAChC;;;OAGG;IACH,cAAc,IAAI,MAAM,EAAE,CAAC;IAC3B;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAKjE;AAuND,eAAO,MAAM,MAAM,EAAE,SAAS,YAAY,EAIzC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,YAAY,CAAC;IACpB,wEAAwE;IACxE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,kEAAkE;IAClE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,WAAW,EAAE,CAqB5C"}