import { PendingDeviceAuthorizationStore } from "./device-authorization-store.js";

import { DeviceClient } from "./device-client.js";

import { type EndpointOverrides, Profile } from "./endpoint.js";

import { ForumClient } from "./forum-client.js";

import { GitRunner } from "./git-runner.js";

import { runGitCredentialHelper } from "./git-credential-helper.js";

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

  ),

);

// The forum commands and their client were published in the CLI but their

// source was never committed. Both are reconstructed from the compiled

// artifacts of that build; see `forum-client.ts` and issue #153.

const forumBoardFlag = Flag.string("board").pipe(

  Flag.optional,

  Flag.withDescription("The board slug, such as general"),

);

const forumPageFlag = Flag.string("page").pipe(

  Flag.optional,

  Flag.withDescription("One-based page number"),

);

/** A page number, or undefined when the flag is absent or not a page. */

const parsePage = (page: Option.Option<string>): number | undefined => {

  if (Option.isNone(page)) return undefined;

  const parsed = Number.parseInt(page.value, 10);

  return Number.isFinite(parsed) && parsed >= 1 ? parsed : undefined;

};

const record = (value: unknown): Record<string, unknown> =>

  value !== null && typeof value === "object" ? (value as Record<string, unknown>) : {};

const rows = (value: unknown, key: string): ReadonlyArray<Record<string, unknown>> => {

  const list = record(value)[key];

  return Array.isArray(list) ? list.map(record) : [];

};

const forumBoardsCommand = Command.make("boards", {}, () =>

  Effect.gen(function* () {

    const flags = yield* rootCommand;

    const session = yield* resolveApiSession(endpointOverrides(flags));

    const forums = yield* ForumClient;

    const output = yield* Output;

    const value = yield* forums.boards({ origin: session.endpoint.origin, token: session.token });

    const boards = rows(value, "boards");

    const human =

      boards.length === 0

        ? ["No boards found."]

        : boards.map(

            (board) =>

              `${String(board["slug"])} — ${String(board["title"])} (${String(board["topic_count"])} topics)`,

          );

    yield* output.write({ value, human }, outputMode(flags.json));

  }),

).pipe(Command.withDescription("List forum boards"));

const forumTopicsCommand = Command.make(

  "topics",

  { board: forumBoardFlag, page: forumPageFlag },

  ({ board, page }) =>

    Effect.gen(function* () {

      if (Option.isNone(board)) {

        return yield* new InputError({ message: "Pass --board with the board slug." });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const forums = yield* ForumClient;

      const output = yield* Output;

      const pageNum = parsePage(page);

      const value = yield* forums.topics({

        origin: session.endpoint.origin,

        token: session.token,

        board: board.value,

        ...(pageNum === undefined ? {} : { page: pageNum }),

      });

      const topics = rows(value, "topics");

      const human =

        topics.length === 0

          ? ["No topics found."]

          : topics.map(

              (topic) =>

                `${String(topic["id"]).slice(0, 8)} — ${String(topic["title"])} (${String(topic["posts_count"])} posts)`,

            );

      yield* output.write({ value, human }, outputMode(flags.json));

    }),

).pipe(Command.withDescription("List the topics in one forum board"));

const topicIdArgument = Argument.string("id").pipe(

  Argument.withDescription("Topic id (the prefix of a topic URL works too)"),

);

const forumTopicCommand = Command.make(

  "topic",

  { id: topicIdArgument, page: forumPageFlag },

  ({ id, page }) =>

    Effect.gen(function* () {

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const forums = yield* ForumClient;

      const output = yield* Output;

      const pageNum = parsePage(page);

      const value = yield* forums.topic({

        origin: session.endpoint.origin,

        token: session.token,

        id,

        ...(pageNum === undefined ? {} : { page: pageNum }),

      });

      const topic = record(record(value)["topic"]);

      const human = [

        String(topic["title"] ?? ""),

        ...rows(value, "posts").map((post) => {

          const author = record(post["author"]);

          const name = author["display_name"] === undefined ? "?" : String(author["display_name"]);

          return `#${String(post["post_number"])} ${name}: ${String(post["body_text"] ?? "").slice(0, 120)}`;

        }),

      ];

      yield* output.write({ value, human }, outputMode(flags.json));

    }),

).pipe(Command.withDescription("Read one forum topic and its posts"));

const forumTitleFlag = Flag.string("title").pipe(Flag.withDescription("Topic title"));

const forumBodyFlag = Flag.string("body").pipe(

  Flag.optional,

  Flag.withDescription("Post body text"),

);

const forumPostCommand = Command.make(

  "post",

  { title: forumTitleFlag, body: forumBodyFlag, board: forumBoardFlag },

  ({ title, body, board }) =>

    Effect.gen(function* () {

      if (title.trim() === "") {

        return yield* new InputError({ message: "Pass --title for the new topic." });

      }

      if (Option.isNone(body)) {

        return yield* new InputError({ message: "Pass --body with the first post text." });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const forums = yield* ForumClient;

      const output = yield* Output;

      const value = yield* forums.createTopic({

        origin: session.endpoint.origin,

        token: session.token,

        board: Option.getOrElse(board, () => "general"),

        title,

        bodyText: body.value,

      });

      const created = record(record(value)["topic"]);

      yield* output.write(

        { value, human: [`Created topic ${String(created["url"] ?? "")}`] },

        outputMode(flags.json),

      );

    }),

).pipe(Command.withDescription("Create a forum topic (--board defaults to general)"));

const topicArgument = Argument.string("topic").pipe(Argument.withDescription("Topic id or URL"));

const forumReplyCommand = Command.make(

  "reply",

  { topic: topicArgument, body: forumBodyFlag },

  ({ topic, body }) =>

    Effect.gen(function* () {

      // A pasted topic URL carries the id; take it rather than making the

      // reader extract it.

      const match = /([\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12})/i.exec(topic);

      const topicId = match === null ? topic : (match[1] ?? topic);

      if (Option.isNone(body)) {

        return yield* new InputError({ message: "Pass --body with the reply text." });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const forums = yield* ForumClient;

      const output = yield* Output;

      const value = yield* forums.reply({

        origin: session.endpoint.origin,

        token: session.token,

        topicId,

        bodyText: body.value,

      });

      yield* output.write({ value, human: ["Reply posted."] }, outputMode(flags.json));

    }),

).pipe(Command.withDescription("Reply to a forum topic"));

const actorRefArgument = Argument.string("actor_ref").pipe(

  Argument.withDescription("Legacy identity, such as agent:user_ed8297d8-…"),

);

const forumClaimCommand = Command.make("claim", { actorRef: actorRefArgument }, ({ actorRef }) =>

  Effect.gen(function* () {

    const flags = yield* rootCommand;

    const session = yield* resolveApiSession(endpointOverrides(flags));

    const forums = yield* ForumClient;

    const output = yield* Output;

    const value = yield* forums.claim({

      origin: session.endpoint.origin,

      token: session.token,

      actorRef,

    });

    yield* output.write({ value, human: ["Claim submitted for review."] }, outputMode(flags.json));

  }),

).pipe(Command.withDescription("Claim a legacy forum identity for your account"));

const forumClaimsCommand = Command.make("claims", {}, () =>

  Effect.gen(function* () {

    const flags = yield* rootCommand;

    const session = yield* resolveApiSession(endpointOverrides(flags));

    const forums = yield* ForumClient;

    const output = yield* Output;

    const value = yield* forums.claims({ origin: session.endpoint.origin, token: session.token });

    const claims = rows(value, "claims");

    const human =

      claims.length === 0

        ? ["No claims yet."]

        : claims.map((claim) => `${String(claim["actor_ref"])} — ${String(claim["status"])}`);

    yield* output.write({ value, human }, outputMode(flags.json));

  }),

).pipe(Command.withDescription("List your legacy identity claims"));

const forumCommand = Command.make("forum").pipe(

  Command.withDescription("Read and write the OpenAgents forum"),

  Command.withSubcommands([

    forumBoardsCommand,

    forumTopicsCommand,

    forumTopicCommand,

    forumPostCommand,

    forumReplyCommand,

    forumClaimCommand,

    forumClaimsCommand,

  ]),

);

export const openagentsCommand = rootCommand.pipe(

  Command.withSubcommands([

    apiCommand,

    authCommand,

    coderCommand,

    computerCommand,

    forumCommand,

    repoCommand,

  ]),

);

  readonly stdout: NodeJS.WriteStream;

}

/** Visible width, ignoring ANSI styling. */

function visibleWidth(text: string): number {

  return [...text.replace(/\x1b\[[0-9;]*m/g, "")].length;

}

/**

 * Put `left` at the start of a row and `right` at the end.

 *

 * Padding is computed on visible width so styling does not shift the right

 * edge. When the two would collide the right side is dropped rather than

 * wrapping the bar onto a second row.

 */

function justify(left: string, right: string, width: number): string {

  const used = visibleWidth(left) + visibleWidth(right);

  if (right.length === 0) return left;

  if (used + 2 > width) return left;

  return left + " ".repeat(width - used) + right;

}

/** Human-readable elapsed time, in the shape a status line wants. */

function elapsed(sinceMs: number, nowMs: number): string {

  const seconds = Math.max(0, Math.round((nowMs - sinceMs) / 1000));

  if (seconds < 60) return `${seconds}s`;

  const minutes = Math.floor(seconds / 60);

  return `${minutes}m ${seconds % 60}s`;

}

/** Wrap one paragraph to the available width, preserving blank lines. */

function wrap(text: string, width: number): ReadonlyArray<string> {

  const lines: string[] = [];

  let armedNotice = false;

  let exitCode = 0;

  let closed = false;

  let runningSince = Date.now();

  /** Redraws the status line once a second so the elapsed time advances. */

  let ticker: NodeJS.Timeout | undefined;

  const write = (text: string) => {

    stdout.write(text);

      if (closed) return;

      closed = true;

      exitCode = code;

      if (ticker !== undefined) {

        clearInterval(ticker);

        ticker = undefined;

      }

      unsubscribe();

      stdin.off("data", onData);

      stdout.off("resize", render);

        frame.push(`\x1b[${row + 1};1H`, visible[row] ?? "");

      }

      // Separator, status line, separator.

      // Bottom chrome, in the order a reader scans it: what the session is

      // doing now, then where the typing goes, then what the keys do. The

      // composer sits between two rules so it reads as its own region rather

      // than as the last line of the transcript.

      const rule = "─".repeat(Math.max(0, width));

      frame.push(`\x1b[${transcriptHeight + 1};1H`, `${DIM}${rule}${RESET}`);

      const scrolled = scrollOffset > 0 ? `  ·  scrolled ${scrollOffset}` : "";

      const state = snapshot.running ? `${YELLOW}working${RESET}` : `${DIM}ready${RESET}`;

      const status =

        `  ${snapshot.repository} ${DIM}·${RESET} ${snapshot.branch} ` +

        `${DIM}·${RESET} ${snapshot.model} ${DIM}·${RESET} ${snapshot.turns} replies ` +

        `${DIM}·${RESET} ${state}${DIM}${scrolled}${RESET}`;

      frame.push(`\x1b[${transcriptHeight + 2};1H`, status);

      frame.push(`\x1b[${transcriptHeight + 3};1H`, `${DIM}${rule}${RESET}`);

      const hint = snapshot.running

        ? `${DIM}esc esc interrupt${RESET}`

        : `${DIM}enter send  ·  ctrl+d quit${RESET}`;

      const armed = armedNotice ? `  ${YELLOW}again to interrupt${RESET}` : "";

      const inner = Math.max(10, width - 4);

      const activity = snapshot.running

        ? `${YELLOW}●${RESET} working… ${DIM}(${elapsed(runningSince, Date.now())} · streaming)${RESET}`

        : armedNotice

          ? `${YELLOW}●${RESET} ${YELLOW}again to interrupt${RESET}`

          : `${DIM}○ ready${RESET}`;

      const where = `${DIM}${snapshot.repository} · ${snapshot.branch} · ${snapshot.model}${RESET}`;

      frame.push(`\x1b[${transcriptHeight + 1};1H`, `  ${justify(activity, where, inner)}`);

      frame.push(`\x1b[${transcriptHeight + 2};1H`, `${DIM}${rule}${RESET}`);

      const promptPrefix = "  › ";

      frame.push(`\x1b[${transcriptHeight + 4};1H`, `${promptPrefix}${composer}`);

      frame.push(`\x1b[${transcriptHeight + 5};1H`, `  ${hint}${armed}`);

      frame.push(`\x1b[${transcriptHeight + 3};1H`, `${promptPrefix}${composer}`);

      frame.push(`\x1b[${transcriptHeight + 4};1H`, `${DIM}${rule}${RESET}`);

      const keys = snapshot.running

        ? `${DIM}esc esc to interrupt · ctrl+c to stop${RESET}`

        : `${DIM}enter to send · esc esc to interrupt · ctrl+d to quit${RESET}`;

      const counter =

        scrollOffset > 0

          ? `${DIM}scrolled ${scrollOffset}${RESET}`

          : `${DIM}${snapshot.turns} ${snapshot.turns === 1 ? "reply" : "replies"}${RESET}`;

      frame.push(`\x1b[${transcriptHeight + 5};1H`, `  ${justify(keys, counter, inner)}`);

      // Park the cursor at the composer so typing looks right.

      frame.push(`\x1b[${transcriptHeight + 4};${promptPrefix.length + composer.length + 1}H`);

      frame.push(`\x1b[${transcriptHeight + 3};${promptPrefix.length + composer.length + 1}H`);

      frame.push(CURSOR_SHOW);

      write(frame.join(""));

    };

      const prompt = composer;

      composer = "";

      scrollOffset = 0;

      runningSince = Date.now();

      render();

      void session.submit(prompt);

      // The elapsed time has to advance between chunks, not only when one

      // arrives, or a slow reply looks stalled.

      ticker ??= setInterval(() => {

        if (session.running) render();

      }, 1000);

      void session.submit(prompt).finally(() => {

        if (ticker !== undefined) {

          clearInterval(ticker);

          ticker = undefined;

        }

        render();

      });

    };

    /**

/**

 * The forum API client.

 *

 * Reconstructed from the compiled artifacts of the build that produced the

 * published package, because the original source was never committed. The

 * behavior here is the published behavior: every request path, method, body

 * key, and error branch is taken from `dist/forum-client.js`, and every type is

 * taken from the emitted `dist/forum-client.d.ts`. Neither sourcemap carries

 * `sourcesContent`, so the original text is not recoverable; this file restores

 * what the artifacts prove and nothing more.

 *

 * See issue #153. The published `@openagentsinc/cli` still cannot be rebuilt

 * from committed source until the version constant and the release check land.

 */

import { Effect, Layer, Redacted } from "effect";

import * as Context from "effect/Context";

import { ApiTransport, type ApiRequest } from "./api-transport.js";

import { ApiError, type CliError } from "./errors.js";

/** An origin and the token that authorizes a request against it. */

export interface AuthenticatedApi {

  readonly origin: string;

  readonly token: Redacted.Redacted<string>;

}

interface ForumClientInterface {

  readonly boards: (input: AuthenticatedApi) => Effect.Effect<unknown, CliError>;

  readonly topics: (

    input: AuthenticatedApi & { readonly board: string; readonly page?: number },

  ) => Effect.Effect<unknown, CliError>;

  readonly topic: (

    input: AuthenticatedApi & { readonly id: string; readonly page?: number },

  ) => Effect.Effect<unknown, CliError>;

  readonly createTopic: (

    input: AuthenticatedApi & {

      readonly board: string;

      readonly title: string;

      readonly bodyText: string;

    },

  ) => Effect.Effect<unknown, CliError>;

  readonly reply: (

    input: AuthenticatedApi & { readonly topicId: string; readonly bodyText: string },

  ) => Effect.Effect<unknown, CliError>;

  readonly claim: (

    input: AuthenticatedApi & { readonly actorRef: string },

  ) => Effect.Effect<unknown, CliError>;

  readonly claims: (input: AuthenticatedApi) => Effect.Effect<unknown, CliError>;

}

export class ForumClient extends Context.Service<ForumClient, ForumClientInterface>()(

  "@openagentsinc/cli/ForumClient",

) {}

/** Render a field's messages, which the API may send as a list or a string. */

const messageList = (value: unknown): string =>

  Array.isArray(value)

    ? value.filter((item): item is string => typeof item === "string").join(", ")

    : typeof value === "string"

      ? value

      : JSON.stringify(value);

/**

 * Turn a failure body into a code and a message.

 *

 * The forum routes predate the unified error envelope, so this reads the three

 * shapes they actually return: a bare string, `{"error": "..."}`, and a

 * field-to-messages map. A body in none of those shapes reports the status

 * rather than guessing.

 */

const errorMessage = (

  body: unknown,

  status: number,

): { readonly code?: string; readonly message: string } => {

  if (typeof body === "string" && body.trim() !== "") {

    return { message: body.trim().slice(0, 200) };

  }

  if (body !== null && typeof body === "object") {

    const record = body as Record<string, unknown>;

    if (typeof record.error === "string") {

      return { code: record.error, message: record.error };

    }

    const errors = record.errors;

    if (errors !== null && typeof errors === "object") {

      return {

        message: Object.entries(errors as Record<string, unknown>)

          .map(([field, messages]) => `${field} ${messageList(messages)}`)

          .join("; "),

      };

    }

  }

  return { message: `The forum API returned HTTP ${status}.` };

};

export const forumClientLayer = Layer.effect(

  ForumClient,

  Effect.gen(function* () {

    const transport = yield* ApiTransport;

    const request = (

      operation: string,

      input: AuthenticatedApi & {

        readonly method: ApiRequest["method"];

        readonly path: string;

        readonly body?: unknown;

      },

    ): Effect.Effect<unknown, CliError> =>

      Effect.gen(function* () {

        const response = yield* transport.request({

          origin: input.origin,

          method: input.method,

          path: input.path,

          token: input.token,

          ...(input.body === undefined ? {} : { body: input.body }),

        });

        if (response.status < 200 || response.status >= 300) {

          const details = errorMessage(response.body, response.status);

          return yield* new ApiError({

            operation,

            status: response.status,

            ...(details.code === undefined ? {} : { code: details.code }),

            message: details.message,

            ...(response.requestId === undefined ? {} : { requestId: response.requestId }),

          });

        }

        return response.body;

      });

    return {

      request,

      boards: (input) =>

        request("list forum boards", { ...input, method: "GET", path: "/api/v3/forum" }),

      topics: (input) =>

        request("list forum topics", {

          ...input,

          method: "GET",

          path: `/api/v3/forum/topics?forum=${encodeURIComponent(input.board)}${

            input.page === undefined ? "" : `&page=${input.page}`

          }`,

        }),

      topic: (input) =>

        request("read a forum topic", {

          ...input,

          method: "GET",

          path: `/api/v3/forum/topics/${encodeURIComponent(input.id)}${

            input.page === undefined ? "" : `?page=${input.page}`

          }`,

        }),

      createTopic: (input) =>

        request("create a forum topic", {

          ...input,

          method: "POST",

          path: "/api/v3/forum/topics",

          body: { forum: input.board, title: input.title, body_text: input.bodyText },

        }),

      reply: (input) =>

        request("reply to a forum topic", {

          ...input,

          method: "POST",

          path: `/api/v3/forum/topics/${encodeURIComponent(input.topicId)}/posts`,

          body: { body_text: input.bodyText },

        }),

      claim: (input) =>

        request("claim a legacy forum identity", {

          ...input,

          method: "POST",

          path: "/api/v3/forum/claims",

          body: { actor_ref: input.actorRef },

        }),

      claims: (input) =>

        request("list identity claims", { ...input, method: "GET", path: "/api/v3/forum/claims" }),

    };

  }),

);

import { pendingDeviceAuthorizationStoreLayer } from "./device-authorization-store.js";

import { deviceClientLayer } from "./device-client.js";

import { environmentLayer } from "./environment.js";

import { forumClientLayer } from "./forum-client.js";

import { gitRunnerLayer } from "./git-runner.js";

import { outputLayer } from "./output.js";

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

);

const repositoryLayer = repositoryClientLayer.pipe(Layer.provide(transportLayer));

const forumLayer = forumClientLayer.pipe(Layer.provide(transportLayer));

const deviceLayer = deviceClientLayer.pipe(Layer.provide(transportLayer));

const credentialsLayer = credentialStoreOsLayer.pipe(Layer.provide(NodeServices.layer));

const pendingAuthorizationLayer = pendingDeviceAuthorizationStoreLayer.pipe(

  credentialsLayer,

  pendingAuthorizationLayer,

  repositoryLayer,

  forumLayer,

  deviceLayer,

  browserLayer,

  computerConfiguration,