import { RequestBodyInput } from "./request-body-input.js";

import { SecretInput } from "./secret-input.js";

import { findToken, resolveApiEndpoint, resolveApiSession } from "./session.js";

import { makeTraceCommand } from "./trace-command.js";

import { TerminalSession } from "./terminal-session.js";

// The version lives in `package.json`; see `version.ts`.

  ]),

);

const traceCommand = makeTraceCommand(rootCommand);

export const openagentsCommand = rootCommand.pipe(

  Command.withSubcommands([

    apiCommand,

    issueCommand,

    projectCommand,

    repoCommand,

    traceCommand,

  ]),

);

  { message: Schema.String },

) {}

export class TraceUploadUnsupported extends Schema.TaggedErrorClass<TraceUploadUnsupported>()(

  "OpenAgentsCli.TraceUploadUnsupported",

  { message: Schema.String },

) {}

export type CliError =

  | InputError

  | ConfigurationError

  | ComputerStatusNetworkFailure

  | ComputerMachineUnavailable

  | ComputerMachineMismatch

  | ComputerReconnectExhausted;

  | ComputerReconnectExhausted

  | TraceUploadUnsupported;

export const exitCodeFor = (error: CliError): number => {

  switch (error._tag) {

      return 14;

    case "OpenAgentsCli.ComputerReconnectExhausted":

      return 15;

    case "OpenAgentsCli.TraceUploadUnsupported":

      return 16;

    case "OpenAgentsCli.AuthenticationRequired":

    case "OpenAgentsCli.CredentialPersistenceUnavailable":

    case "OpenAgentsCli.CredentialStoreError":

  "OpenAgentsCli.ComputerMachineUnavailable",

  "OpenAgentsCli.ComputerMachineMismatch",

  "OpenAgentsCli.ComputerReconnectExhausted",

  "OpenAgentsCli.TraceUploadUnsupported",

]);

const isCliError = (value: unknown): value is CliError =>

/**

 * The `openagents trace` command family.

 *

 * This is the LOCAL half of the trace pipeline: list what session exports

 * exist on this machine, summarize one, and produce a redacted sibling copy.

 * The upload half needs a forge ingest route that does not exist yet, so

 * `trace upload` refuses with a typed error that names the missing route

 * instead of pretending.

 *

 * The family is defined through a factory taking the root command, so the

 * registration hunk in `cli.ts` stays a single import and a single list entry.

 */

import { existsSync } from "node:fs";

import { homedir } from "node:os";

import { isAbsolute, join, resolve } from "node:path";

import { Effect } from "effect";

import { Argument, Command, Flag } from "effect/unstable/cli";

import { InputError, TraceUploadUnsupported } from "./errors.js";

import { Output, type OutputMode } from "./output.js";

import {

  defaultDiscoveryBounds,

  defaultTraceStores,

  pathTraceStore,

  redactTraceFile,

  scanTraceStore,

  summarizeTraceFile,

  type TraceCandidate,

  type TraceStoreSpec,

  type TraceSummary,

} from "./trace-store.js";

/** The shared flags a trace handler reads back off the root command. */

interface SharedFlags {

  readonly json: boolean;

}

const outputMode = (json: boolean): OutputMode => (json ? "json" : "human");

/** The server half `trace upload` is waiting for. One place, one sentence. */

export const TRACE_INGEST_ROUTE_GAP =

  "openagents.com has no trace ingest route yet. Upload needs the server half first: " +

  "POST /api/v3/traces accepting an ATIF v1.7 document with owner_only default visibility. " +

  "Until that route exists, this command refuses rather than pretending to upload.";

const listPathFlag = Flag.string("path").pipe(

  Flag.atLeast(0),

  Flag.withDescription(

    "Scan only this directory for trace documents; repeatable. Omit to scan the default stores.",

  ),

);

const listLimitFlag = Flag.integer("limit").pipe(

  Flag.withDefault(20),

  Flag.withDescription("Most files listed per store, newest first"),

);

const extraPathStores = (): ReadonlyArray<TraceStoreSpec> =>

  (process.env["OPENAGENTS_TRACE_PATHS"] ?? "")

    .split(":")

    .map((entry) => entry.trim())

    .filter((entry) => entry.length > 0)

    .map((entry) => pathTraceStore(resolve(entry)));

const candidateLine = (candidate: TraceCandidate): string =>

  `${candidate.kind}  ${candidate.modified_at}  ${candidate.bytes}B  ${candidate.path}`;

const summaryHuman = (summary: TraceSummary): ReadonlyArray<string> => {

  if (summary.format !== "atif") {

    return [

      `File: ${summary.path}`,

      `Format: ${summary.format === "jsonl" ? "line-delimited session log (not ATIF)" : "unknown"}`,

      `Size: ${summary.bytes} bytes`,

      ...(summary.lines === undefined ? [] : [`Lines: ${summary.lines}`]),

      "This slice summarizes ATIF documents only; foreign logs get metadata.",

    ];

  }

  const bySource = summary.steps_by_source ?? {};

  const tokens =

    summary.total_prompt_tokens === undefined && summary.total_completion_tokens === undefined

      ? "not recorded"

      : `${summary.total_prompt_tokens ?? 0} prompt, ${summary.total_completion_tokens ?? 0} completion`;

  return [

    `File: ${summary.path}`,

    `Schema: ${summary.schema_version ?? "(missing schema_version)"}`,

    ...(summary.session_id === undefined ? [] : [`Session: ${summary.session_id}`]),

    ...(summary.agent === undefined

      ? []

      : [`Agent: ${summary.agent.name ?? "unknown"} (${summary.agent.model ?? "unknown model"})`]),

    `Steps: ${summary.steps ?? 0} (${Object.entries(bySource)

      .map(([source, count]) => `${source} ${count}`)

      .join(", ")})`,

    `Models: ${(summary.models ?? []).join(", ") || "(none recorded)"}`,

    `Tool calls: ${summary.tool_calls ?? 0}`,

    `Tokens: ${tokens}`,

    ...(summary.first_timestamp === undefined || summary.last_timestamp === undefined

      ? []

      : [`Span: ${summary.first_timestamp} to ${summary.last_timestamp}`]),

  ];

};

/**

 * Resolve a `<path|id>` argument. A bare name that is not a file on disk is

 * tried as a file in the local export store, which is where `/export` writes.

 */

const resolveTraceArgument = Effect.fn("Trace.resolveTraceArgument")(function* (value: string) {

  const direct = isAbsolute(value) ? value : resolve(value);

  if (existsSync(direct)) return direct;

  const inExports = join(homedir(), ".openagents", "exports", value);

  if (!value.includes("/") && existsSync(inExports)) return inExports;

  return yield* new InputError({

    message: `No trace file exists at ${value}, and ~/.openagents/exports has no file by that name. Run openagents trace list to see what is discoverable.`,

  });

});

export const makeTraceCommand = <R>(root: Effect.Effect<SharedFlags, never, R>) => {

  const traceListCommand = Command.make(

    "list",

    { path: listPathFlag, limit: listLimitFlag },

    ({ limit, path }) =>

      Effect.gen(function* () {

        if (limit <= 0) {

          return yield* new InputError({ message: "--limit must be greater than zero." });

        }

        const flags = yield* root;

        const output = yield* Output;

        const stores =

          path.length > 0

            ? path.map((entry) => pathTraceStore(resolve(entry)))

            : [...defaultTraceStores(homedir()), ...extraPathStores()];

        const bounds = { ...defaultDiscoveryBounds, maxFilesPerStore: limit };

        const results = yield* Effect.sync(() =>

          stores.map((store) => scanTraceStore(store, bounds)),

        );

        const scans = results.map((result) => result.scan);

        const traces = results

          .flatMap((result) => result.candidates)

          .sort((a, b) => b.modified_at.localeCompare(a.modified_at));

        yield* output.write(

          {

            value: { schema: "openagents.trace_list.v1", stores: scans, traces },

            human: [

              ...scans.map(

                (scan) =>

                  `${scan.kind}: ${scan.root} ${

                    scan.present

                      ? `(${scan.matched} matched, ${scan.listed} listed${

                          scan.skipped_symlinks > 0

                            ? `, ${scan.skipped_symlinks} symlinks skipped`

                            : ""

                        }${scan.truncated ? ", scan truncated at its entry budget" : ""})`

                      : "(not present)"

                  }`,

              ),

              ...(traces.length === 0 ? ["No trace files found."] : traces.map(candidateLine)),

            ],

          },

          outputMode(flags.json),

        );

      }),

  ).pipe(

    Command.withDescription(

      "Discover local coding-agent session exports: the OpenAgents export store plus known Claude and Codex session directories. Read-only, bounded, and symlink-safe; foreign stores are listed as metadata only.",

    ),

  );

  const traceArgument = Argument.string("trace").pipe(

    Argument.withDescription("A trace file path, or a file name inside ~/.openagents/exports"),

  );

  const traceShowCommand = Command.make("show", { trace: traceArgument }, ({ trace }) =>

    Effect.gen(function* () {

      const flags = yield* root;

      const output = yield* Output;

      const path = yield* resolveTraceArgument(trace);

      const summary = yield* Effect.try({

        try: () => summarizeTraceFile(path),

        catch: () => new InputError({ message: `The trace file at ${path} could not be read.` }),

      });

      yield* output.write(

        {

          value: { schema: "openagents.trace_summary.v1", ...summary },

          human: summaryHuman(summary),

        },

        outputMode(flags.json),

      );

    }),

  ).pipe(

    Command.withDescription(

      "Summarize one trace: steps, sources, models, tool calls, and token totals, without printing any payload.",

    ),

  );

  const traceRedactCommand = Command.make("redact", { trace: traceArgument }, ({ trace }) =>

    Effect.gen(function* () {

      const flags = yield* root;

      const output = yield* Output;

      const path = yield* resolveTraceArgument(trace);

      if (path.endsWith(".redacted.json") || path.endsWith(".redacted.jsonl")) {

        return yield* new InputError({

          message: `${path} is already a redacted copy; redact the original instead.`,

        });

      }

      const result = yield* Effect.try({

        try: () => redactTraceFile(path, homedir()),

        catch: () =>

          new InputError({ message: `The trace file at ${path} could not be redacted.` }),

      });

      yield* output.write(

        {

          value: { schema: "openagents.trace_redaction.v1", ...result },

          human: [

            `Wrote ${result.output}`,

            result.total === 0

              ? "Nothing matched the redaction rules."

              : `Redacted ${result.total} match${result.total === 1 ? "" : "es"}: ${Object.entries(

                  result.counts,

                )

                  .map(([category, count]) => `${category} ${count}`)

                  .join(", ")}`,

            ...(result.valid_json === false

              ? ["Warning: the redacted copy no longer parses as JSON; review it before sharing."]

              : []),

          ],

        },

        outputMode(flags.json),

      );

    }),

  ).pipe(

    Command.withDescription(

      "Write a conservatively redacted sibling copy (.redacted.json): bearer and API tokens, JWTs, secret-named fields, environment-variable values, and home paths are removed. Only counts are reported; the matched text is never echoed.",

    ),

  );

  const uploadPublicFlag = Flag.boolean("public").pipe(

    Flag.withDescription("Ask for public visibility instead of the owner_only default"),

  );

  const uploadUnlistedFlag = Flag.boolean("unlisted").pipe(

    Flag.withDescription("Ask for unlisted visibility instead of the owner_only default"),

  );

  const traceUploadCommand = Command.make(

    "upload",

    { trace: traceArgument, public: uploadPublicFlag, unlisted: uploadUnlistedFlag },

    ({ public: isPublic, trace, unlisted }) =>

      Effect.gen(function* () {

        if (isPublic && unlisted) {

          return yield* new InputError({ message: "Use either --public or --unlisted, not both." });

        }

        // Validate the local half first so the refusal is about the real gap,

        // not about a path typo the reader would rather hear about now.

        yield* resolveTraceArgument(trace);

        return yield* new TraceUploadUnsupported({ message: TRACE_INGEST_ROUTE_GAP });

      }),

  ).pipe(

    Command.withDescription(

      "Upload a redacted trace to openagents.com with owner_only visibility by default. The forge ingest route does not exist yet, so this refuses and names the missing server half.",

    ),

  );

  return Command.make("trace").pipe(

    Command.withDescription(

      "Discover, inspect, and redact local coding-agent traces (ATIF). Discovery is read-only; nothing here rewrites or deletes a source session record.",

    ),

    Command.withSubcommands([

      traceListCommand,

      traceShowCommand,

      traceRedactCommand,

      traceUploadCommand,

    ]),

  );

};

/**

 * Local trace discovery, summarization, and redaction.

 *

 * A trace is the public-safe ATIF projection of a coding-agent session. This

 * module owns the LOCAL half of `openagents trace`: finding candidate session

 * exports on this machine, summarizing one without dumping its payloads, and

 * producing a conservatively redacted sibling copy.

 *

 * Discovery is read-only and bounded by construction. Every directory walk

 * uses `lstat`, never follows a symlink, visits a capped number of entries to

 * a capped depth, and lists a capped number of files. Foreign stores -- the

 * Claude and Codex session directories -- are metadata-only: path, size,

 * mtime, kind. Nothing here ever writes into a foreign store.

 */

import { lstatSync, readdirSync, readFileSync, writeFileSync } from "node:fs";

import { join } from "node:path";

/** Where a candidate trace came from. */

export type TraceSourceKind =

  | "openagents_export"

  | "claude_session"

  | "codex_session"

  | "trace_path";

/** One discovered file, metadata only. */

export interface TraceCandidate {

  readonly path: string;

  readonly kind: TraceSourceKind;

  readonly bytes: number;

  readonly modified_at: string;

}

/** What a single store scan did, so bounds are visible in the output. */

export interface TraceStoreScan {

  readonly root: string;

  readonly kind: TraceSourceKind;

  readonly present: boolean;

  /** Files that matched the store's extensions, before the listing cap. */

  readonly matched: number;

  /** Files included in the listing after the cap. */

  readonly listed: number;

  /** Symlinks seen and refused. Discovery never follows one. */

  readonly skipped_symlinks: number;

  /** Whether the walk stopped at its entry budget rather than the store's end. */

  readonly truncated: boolean;

}

/** A directory to scan and how to read it. */

export interface TraceStoreSpec {

  readonly root: string;

  readonly kind: TraceSourceKind;

  readonly extensions: ReadonlyArray<string>;

}

export interface DiscoveryBounds {

  /** Directory depth below the root; 0 scans only the root's own entries. */

  readonly maxDepth: number;

  /** Most files listed per store, newest first. */

  readonly maxFilesPerStore: number;

  /** Hard budget of directory entries visited per store. */

  readonly maxScanEntries: number;

}

export const defaultDiscoveryBounds: DiscoveryBounds = {

  maxDepth: 4,

  maxFilesPerStore: 20,

  maxScanEntries: 5000,

};

/** The stores `trace list` scans when no explicit path is given. */

export const defaultTraceStores = (home: string): ReadonlyArray<TraceStoreSpec> => [

  {

    root: join(home, ".openagents", "exports"),

    kind: "openagents_export",

    extensions: [".json"],

  },

  { root: join(home, ".claude", "projects"), kind: "claude_session", extensions: [".jsonl"] },

  { root: join(home, ".codex", "sessions"), kind: "codex_session", extensions: [".jsonl"] },

];

/** A store spec for a user-supplied directory of ATIF documents. */

export const pathTraceStore = (root: string): TraceStoreSpec => ({

  root,

  kind: "trace_path",

  extensions: [".json", ".jsonl"],

});

const matchesExtension = (name: string, extensions: ReadonlyArray<string>): boolean =>

  extensions.some((extension) => name.endsWith(extension));

/**

 * Scan one store within the given bounds.

 *

 * Iterative breadth-first walk. Symlinks -- file or directory -- are counted

 * and skipped, so a link planted in a session store can neither escape it nor

 * loop it. The entry budget bounds the walk on stores of any size.

 */

export const scanTraceStore = (

  spec: TraceStoreSpec,

  bounds: DiscoveryBounds = defaultDiscoveryBounds,

): { readonly scan: TraceStoreScan; readonly candidates: ReadonlyArray<TraceCandidate> } => {

  const rootStat = (() => {

    try {

      return lstatSync(spec.root);

    } catch {

      return undefined;

    }

  })();

  if (rootStat === undefined || rootStat.isSymbolicLink() || !rootStat.isDirectory()) {

    return {

      scan: {

        root: spec.root,

        kind: spec.kind,

        present: false,

        matched: 0,

        listed: 0,

        skipped_symlinks: rootStat?.isSymbolicLink() === true ? 1 : 0,

        truncated: false,

      },

      candidates: [],

    };

  }

  const found: Array<{ path: string; bytes: number; mtimeMs: number }> = [];

  let skippedSymlinks = 0;

  let visited = 0;

  let truncated = false;

  const queue: Array<{ directory: string; depth: number }> = [{ directory: spec.root, depth: 0 }];

  while (queue.length > 0) {

    const next = queue.shift();

    if (next === undefined) break;

    const names = (() => {

      try {

        return readdirSync(next.directory);

      } catch {

        return [] as ReadonlyArray<string>;

      }

    })();

    for (const name of names) {

      if (visited >= bounds.maxScanEntries) {

        truncated = true;

        break;

      }

      visited += 1;

      const path = join(next.directory, name);

      const stat = (() => {

        try {

          return lstatSync(path);

        } catch {

          return undefined;

        }

      })();

      if (stat === undefined) continue;

      if (stat.isSymbolicLink()) {

        skippedSymlinks += 1;

        continue;

      }

      if (stat.isDirectory()) {

        if (next.depth < bounds.maxDepth) queue.push({ directory: path, depth: next.depth + 1 });

        continue;

      }

      if (stat.isFile() && matchesExtension(name, spec.extensions)) {

        found.push({ path, bytes: stat.size, mtimeMs: stat.mtimeMs });

      }

    }

    if (truncated) break;

  }

  const newestFirst = [...found].sort((a, b) => b.mtimeMs - a.mtimeMs);

  const listed = newestFirst.slice(0, bounds.maxFilesPerStore);

  return {

    scan: {

      root: spec.root,

      kind: spec.kind,

      present: true,

      matched: found.length,

      listed: listed.length,

      skipped_symlinks: skippedSymlinks,

      truncated,

    },

    candidates: listed.map((file) => ({

      path: file.path,

      kind: spec.kind,

      bytes: file.bytes,

      modified_at: new Date(file.mtimeMs).toISOString(),

    })),

  };

};

/** What `trace show` reports about one document. Payloads stay in the file. */

export interface TraceSummary {

  readonly path: string;

  readonly format: "atif" | "jsonl" | "unknown";

  readonly bytes: number;

  readonly schema_version?: string;

  readonly session_id?: string;

  readonly agent?: { readonly name?: string; readonly model?: string };

  readonly steps?: number;

  readonly steps_by_source?: Readonly<Record<string, number>>;

  readonly models?: ReadonlyArray<string>;

  readonly tool_calls?: number;

  readonly total_prompt_tokens?: number;

  readonly total_completion_tokens?: number;

  readonly first_timestamp?: string;

  readonly last_timestamp?: string;

  readonly lines?: number;

}

const asRecord = (value: unknown): Record<string, unknown> | undefined =>

  typeof value === "object" && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : undefined;

const asNumber = (value: unknown): number | undefined =>

  typeof value === "number" && Number.isFinite(value) ? value : undefined;

/**

 * Summarize one trace file: counts, models, and token totals, never payloads.

 *

 * An ATIF document gets the full summary. A line-delimited session log -- the

 * shape the foreign stores hold -- gets bytes and line count only, because

 * this slice does not parse foreign formats.

 */

export const summarizeTraceFile = (path: string): TraceSummary => {

  const text = readFileSync(path, "utf8");

  const bytes = Buffer.byteLength(text, "utf8");

  const document = (() => {

    try {

      return asRecord(JSON.parse(text));

    } catch {

      return undefined;

    }

  })();

  if (document !== undefined && Array.isArray(document["steps"])) {

    const steps = document["steps"].map(asRecord).filter((step) => step !== undefined);

    const bySource: Record<string, number> = {};

    const models = new Set<string>();

    let toolCalls = 0;

    let promptTokens = 0;

    let completionTokens = 0;

    let sawTokens = false;

    for (const step of steps) {

      const source = typeof step["source"] === "string" ? step["source"] : "unknown";

      bySource[source] = (bySource[source] ?? 0) + 1;

      if (typeof step["model_name"] === "string") models.add(step["model_name"]);

      if (Array.isArray(step["tool_calls"])) toolCalls += step["tool_calls"].length;

      const metrics = asRecord(step["metrics"]);

      if (metrics !== undefined) {

        const prompt = asNumber(metrics["prompt_tokens"]);

        const completion = asNumber(metrics["completion_tokens"]);

        if (prompt !== undefined || completion !== undefined) sawTokens = true;

        promptTokens += prompt ?? 0;

        completionTokens += completion ?? 0;

      }

    }

    const agent = asRecord(document["agent"]);

    const finalMetrics = asRecord(document["final_metrics"]);

    const totalPrompt = asNumber(finalMetrics?.["total_prompt_tokens"]);

    const totalCompletion = asNumber(finalMetrics?.["total_completion_tokens"]);

    const first = steps[0];

    const last = steps[steps.length - 1];

    return {

      path,

      format: "atif",

      bytes,

      ...(typeof document["schema_version"] === "string"

        ? { schema_version: document["schema_version"] }

        : {}),

      ...(typeof document["session_id"] === "string" ? { session_id: document["session_id"] } : {}),

      ...(agent === undefined

        ? {}

        : {

            agent: {

              ...(typeof agent["name"] === "string" ? { name: agent["name"] } : {}),

              ...(typeof agent["model_name"] === "string" ? { model: agent["model_name"] } : {}),

            },

          }),

      steps: steps.length,

      steps_by_source: bySource,

      models: [...models],

      tool_calls: toolCalls,

      ...(totalPrompt !== undefined

        ? { total_prompt_tokens: totalPrompt }

        : sawTokens

          ? { total_prompt_tokens: promptTokens }

          : {}),

      ...(totalCompletion !== undefined

        ? { total_completion_tokens: totalCompletion }

        : sawTokens

          ? { total_completion_tokens: completionTokens }

          : {}),

      ...(first !== undefined && typeof first["timestamp"] === "string"

        ? { first_timestamp: first["timestamp"] }

        : {}),

      ...(last !== undefined && typeof last["timestamp"] === "string"

        ? { last_timestamp: last["timestamp"] }

        : {}),

    };

  }

  if (path.endsWith(".jsonl")) {

    const lines = text.split("\n").filter((line) => line.trim().length > 0).length;

    return { path, format: "jsonl", bytes, lines };

  }

  return { path, format: "unknown", bytes };

};

/**

 * One redaction rule: a category name, a global pattern, and its replacement.

 *

 * The list is data so a test can plant a fake secret per category and assert

 * both that the secret is gone and that the count names the category. Order

 * matters: specific shapes run before broad ones so a bearer token is counted

 * as a bearer token, not as an environment value.

 */

export interface RedactionRule {

  readonly category: string;

  readonly pattern: RegExp;

  readonly replacement: string;

}

const escapeForRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

/** The conservative rule set. `home` scopes the path rules to this machine. */

export const redactionRules = (home: string): ReadonlyArray<RedactionRule> => [

  {

    category: "bearer_token",

    pattern: /\b[Bb]earer\s+[A-Za-z0-9._~+/=-]{8,}/g,

    replacement: "Bearer [REDACTED:bearer_token]",

  },

  {

    category: "api_key",

    pattern:

      /\b(?:sk-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|gho_[A-Za-z0-9]{20,}|glpat-[A-Za-z0-9_-]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[A-Z0-9]{16}|AIza[A-Za-z0-9_-]{30,})\b/g,

    replacement: "[REDACTED:api_key]",

  },

  {

    category: "jwt",

    pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,

    replacement: "[REDACTED:jwt]",

  },

  {

    category: "secret_field",

    pattern:

      /("[\w.-]*(?:token|secret|password|passwd|api[_-]?key|credential|private[_-]?key)[\w.-]*"\s*:\s*)"(?:[^"\\]|\\.)*"/gi,

    replacement: '$1"[REDACTED:secret_field]"',

  },

  {

    category: "env_value",

    pattern: /\b([A-Z][A-Z0-9_]{2,})=(["'])(?:(?!\2)[^\n]){4,}?\2/g,

    replacement: "$1=[REDACTED:env_value]",

  },

  {

    category: "env_value",

    pattern: /\b([A-Z][A-Z0-9_]{2,})=(?!\[REDACTED)[^\s"'`\\,}]{4,}/g,

    replacement: "$1=[REDACTED:env_value]",

  },

  {

    category: "home_path",

    pattern: new RegExp(escapeForRegExp(home), "g"),

    replacement: "~",

  },

  {

    category: "home_path",

    pattern: /(?:\/Users|\/home)\/[A-Za-z0-9._-]+/g,

    replacement: "~",

  },

];

export interface RedactionResult {

  readonly text: string;

  /** Matches per category. Counts only; the matched text is never returned. */

  readonly counts: Readonly<Record<string, number>>;

  readonly total: number;

}

/** Apply the rules to a text and count what each category removed. */

export const redactText = (text: string, rules: ReadonlyArray<RedactionRule>): RedactionResult => {

  const counts: Record<string, number> = {};

  let output = text;

  let total = 0;

  for (const rule of rules) {

    let matched = 0;

    output = output.replace(rule.pattern, (...args) => {

      matched += 1;

      // Rebuild the replacement's capture references by hand: the replacement

      // string is data, and String.replace only expands `$1` for literal

      // second arguments.

      return rule.replacement.replace(/\$(\d)/g, (_, index: string) => {

        const capture = args[Number(index)] as unknown;

        return typeof capture === "string" ? capture : "";

      });

    });

    if (matched > 0) {

      counts[rule.category] = (counts[rule.category] ?? 0) + matched;

      total += matched;

    }

  }

  return { text: output, counts, total };

};

export interface RedactedFile {

  readonly input: string;

  readonly output: string;

  readonly counts: Readonly<Record<string, number>>;

  readonly total: number;

  /** Whether the redacted output still parses, when the input parsed. */

  readonly valid_json: boolean | null;

}

/** The sibling path a redaction writes: `foo.json` becomes `foo.redacted.json`. */

export const redactedPathFor = (path: string): string =>

  path.endsWith(".jsonl")

    ? `${path.slice(0, -".jsonl".length)}.redacted.jsonl`

    : path.endsWith(".json")

      ? `${path.slice(0, -".json".length)}.redacted.json`

      : `${path}.redacted.json`;

/** Redact one file into its sibling and report by count only. */

export const redactTraceFile = (path: string, home: string): RedactedFile => {

  const text = readFileSync(path, "utf8");

  const parsedBefore = (() => {

    try {

      JSON.parse(text);

      return true;

    } catch {

      return false;

    }

  })();

  const result = redactText(text, redactionRules(home));

  const output = redactedPathFor(path);

  writeFileSync(output, result.text, "utf8");

  const validJson = parsedBefore

    ? (() => {

        try {

          JSON.parse(result.text);

          return true;

        } catch {

          return false;

        }

      })()

    : null;

  return {

    input: path,

    output,

    counts: result.counts,

    total: result.total,

    valid_json: validJson,

  };

};

import { mkdtempSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import * as NodeServices from "@effect/platform-node/NodeServices";

import { Effect, Layer } from "effect";

import { describe, expect, it } from "vitest";

import { runCliWith } from "../src/cli.js";

import { credentialStoreUnavailableLayer } from "../src/credential-store.js";

import { environmentLayerFromValues } from "../src/environment.js";

import { outputTestLayer, type OutputDocument, type OutputMode } from "../src/output.js";

import { persistedConfigurationTestLayer } from "../src/persisted-configuration.js";

import { terminalSessionTestLayer } from "../src/terminal-session.js";

interface Written {

  readonly document: OutputDocument;

  readonly mode: OutputMode;

}

const harness = () => {

  const written: Array<Written> = [];

  const layer = Layer.mergeAll(

    NodeServices.layer,

    environmentLayerFromValues({}),

    persistedConfigurationTestLayer({}),

    terminalSessionTestLayer(false),

    credentialStoreUnavailableLayer,

    outputTestLayer((document, mode) =>

      Effect.sync(() => {

        written.push({ document, mode });

      }),

    ),

  );

  const run = (argv: ReadonlyArray<string>) =>

    Effect.runPromise(

      runCliWith([...argv]).pipe(Effect.provide(layer)) as Effect.Effect<void, unknown>,

    );

  const fail = (argv: ReadonlyArray<string>) =>

    Effect.runPromise(

      runCliWith([...argv]).pipe(Effect.provide(layer), Effect.flip) as Effect.Effect<

        unknown,

        unknown

      >,

    );

  return { run, fail, written };

};

const atifDocument = (message: string) => ({

  schema_version: "ATIF-v1.7",

  session_id: "octavia/project-2026-08-24T14:00:00.000Z",

  agent: { name: "openagents-coder", version: "0.3.5", model_name: "Ollama qwen" },

  steps: [

    { step_id: 1, timestamp: "2026-08-24T14:00:00.000Z", source: "user", message },

    {

      step_id: 2,

      timestamp: "2026-08-24T14:00:05.000Z",

      source: "agent",

      message: "done",

      model_name: "Ollama qwen",

      metrics: { prompt_tokens: 5, completion_tokens: 2 },

    },

  ],

  final_metrics: { total_prompt_tokens: 5, total_completion_tokens: 2, total_steps: 2 },

});

const scratchStore = (message = "hello") => {

  const root = mkdtempSync(join(tmpdir(), "trace-command-"));

  const path = join(root, "session-atif.json");

  writeFileSync(path, JSON.stringify(atifDocument(message)), "utf8");

  return { root, path };

};

describe("openagents trace", () => {

  it("lists an explicit store as JSON with scan bounds visible", async () => {

    const { root, path } = scratchStore();

    const { run, written } = harness();

    await run(["--json", "trace", "list", "--path", root]);

    expect(written).toHaveLength(1);

    const value = written[0]?.document.value as {

      schema: string;

      stores: ReadonlyArray<Record<string, unknown>>;

      traces: ReadonlyArray<Record<string, unknown>>;

    };

    expect(value.schema).toBe("openagents.trace_list.v1");

    expect(value.stores).toHaveLength(1);

    expect(value.stores[0]).toMatchObject({

      kind: "trace_path",

      present: true,

      matched: 1,

      listed: 1,

      skipped_symlinks: 0,

      truncated: false,

    });

    expect(value.traces).toHaveLength(1);

    expect(value.traces[0]).toMatchObject({ path, kind: "trace_path" });

  });

  it("skips a planted symlink and says so in the scan", async () => {

    const outside = mkdtempSync(join(tmpdir(), "trace-outside-"));

    writeFileSync(join(outside, "foreign.json"), "{}", "utf8");

    const { root } = scratchStore();

    symlinkSync(join(outside, "foreign.json"), join(root, "linked.json"));

    const { run, written } = harness();

    await run(["--json", "trace", "list", "--path", root]);

    const value = written[0]?.document.value as {

      stores: ReadonlyArray<Record<string, unknown>>;

      traces: ReadonlyArray<{ path: string }>;

    };

    expect(value.stores[0]).toMatchObject({ skipped_symlinks: 1 });

    expect(value.traces.some((trace) => trace.path.includes("linked.json"))).toBe(false);

  });

  it("refuses a non-positive list limit", async () => {

    const { fail } = harness();

    const error = await fail(["trace", "list", "--limit", "0"]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.InputError" });

  });

  it("shows a trace summary without printing payloads", async () => {

    const { path } = scratchStore("the payload text that must not leak");

    const { run, written } = harness();

    await run(["--json", "trace", "show", path]);

    const value = written[0]?.document.value as Record<string, unknown>;

    expect(value).toMatchObject({

      schema: "openagents.trace_summary.v1",

      format: "atif",

      schema_version: "ATIF-v1.7",

      steps: 2,

      steps_by_source: { user: 1, agent: 1 },

      models: ["Ollama qwen"],

      total_prompt_tokens: 5,

      total_completion_tokens: 2,

    });

    expect(JSON.stringify(value)).not.toContain("the payload text that must not leak");

  });

  it("refuses to show a trace that does not exist anywhere", async () => {

    const { fail } = harness();

    const error = await fail(["trace", "show", "no-such-trace-file-atif.json"]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.InputError" });

  });

  it("redacts into a sibling file and reports counts, not secrets", async () => {

    const { root, path } = scratchStore("token OPENAGENTS_TOKEN=super-secret-value here");

    const { run, written } = harness();

    await run(["--json", "trace", "redact", path]);

    const value = written[0]?.document.value as {

      schema: string;

      output: string;

      counts: Record<string, number>;

      total: number;

      valid_json: boolean | null;

    };

    expect(value.schema).toBe("openagents.trace_redaction.v1");

    expect(value.output).toBe(join(root, "session-atif.redacted.json"));

    expect(value.counts["env_value"]).toBe(1);

    expect(value.valid_json).toBe(true);

    expect(JSON.stringify(value)).not.toContain("super-secret-value");

    expect(readFileSync(value.output, "utf8")).not.toContain("super-secret-value");

    expect(readFileSync(path, "utf8")).toContain("super-secret-value");

  });

  it("refuses to redact an already-redacted copy", async () => {

    const { root } = scratchStore();

    const redacted = join(root, "session-atif.redacted.json");

    writeFileSync(redacted, "{}", "utf8");

    const { fail } = harness();

    const error = await fail(["trace", "redact", redacted]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.InputError" });

  });

  it("refuses upload with a typed error naming the missing server route", async () => {

    const { path } = scratchStore();

    const { fail } = harness();

    const error = await fail(["trace", "upload", path]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.TraceUploadUnsupported" });

    expect(String((error as { message: string }).message)).toContain("POST /api/v3/traces");

  });

  it("still validates the local path before refusing an upload", async () => {

    const { fail } = harness();

    const error = await fail(["trace", "upload", "no-such-trace-file-atif.json"]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.InputError" });

  });

  it("refuses --public together with --unlisted", async () => {

    const { path } = scratchStore();

    const { fail } = harness();

    const error = await fail(["trace", "upload", path, "--public", "--unlisted"]);

    expect(error).toMatchObject({ _tag: "OpenAgentsCli.InputError" });