@app-vitals/agent-admin 0.0.1 → 0.1.1

package/src/admin-ui-account.smoke.test.ts

@@ -0,0 +1,286 @@
+/**
+ * admin/src/admin-ui-account.smoke.test.ts
+ * Smoke tests for /admin/account routes (SSP-3.2). In-memory service doubles.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { Hono } from "hono";
+import type { MiddlewareHandler } from "hono";
+import {
+  type AccountRouteDeps,
+  registerAccountRoutes,
+} from "./admin-ui-account.ts";
+import type { AdminUIEnv } from "./admin-ui.ts";
+import {
+  AccountMemberNotFoundError,
+  LastOwnerError,
+} from "./account-members.ts";
+
+const d = new Date("2026-01-01T00:00:00Z");
+
+function setup(
+  opts: { enabled?: boolean; seedMembers?: Array<[string, string]> } = {},
+) {
+  const account = {
+    id: "a1",
+    name: "Acme",
+    status: "active",
+    maxAgents: 2,
+    plan: null,
+    trialExpiresAt: null,
+    trialExpiryWarnedAt: null,
+    createdAt: d,
+    updatedAt: d,
+  };
+  let members = (
+    opts.seedMembers ?? [
+      ["owner@x.com", "owner"],
+      ["member@x.com", "member"],
+    ]
+  ).map(([email, role], i) => ({
+    id: `m${i}`,
+    accountId: "a1",
+    email,
+    role,
+    createdAt: d,
+  }));
+  let invites: Array<{
+    id: string;
+    accountId: string;
+    email: string;
+    invitedBy: string;
+    acceptedAt: null;
+    createdAt: Date;
+  }> = [];
+  const ownersLeft = () => members.filter((m) => m.role === "owner").length;
+
+  const deps: AccountRouteDeps = {
+    enabled: opts.enabled ?? true,
+    requireAuth: (async (c, next) => {
+      c.set("userEmail", c.req.header("x-test-user-email") ?? "owner@x.com");
+      c.set("isAdmin", false);
+      await next();
+    }) as MiddlewareHandler<AdminUIEnv>,
+    html: (content, o) =>
+      new Response(content, {
+        status: o?.status ?? 200,
+        headers: { "Content-Type": "text/html" },
+      }),
+    accounts: {
+      async getByMemberEmail(email) {
+        return members.some((m) => m.email === email.toLowerCase())
+          ? (account as never)
+          : null;
+      },
+      async update(_id, data) {
+        Object.assign(account, data);
+        return account as never;
+      },
+      async countAgents() {
+        return 1;
+      },
+    },
+    members: {
+      async listByAccount() {
+        return members as never;
+      },
+      async getByEmail(email) {
+        return (members.find((m) => m.email === email) ?? null) as never;
+      },
+      async remove(_a, email) {
+        const m = members.find((x) => x.email === email);
+        if (!m) throw new AccountMemberNotFoundError("a1", email);
+        if (m.role === "owner" && ownersLeft() <= 1)
+          throw new LastOwnerError("a1");
+        members = members.filter((x) => x !== m);
+      },
+      async promote(_a, email) {
+        const m = members.find((x) => x.email === email);
+        if (!m) throw new AccountMemberNotFoundError("a1", email);
+        m.role = "owner";
+        return m as never;
+      },
+      async demote(_a, email) {
+        const m = members.find((x) => x.email === email);
+        if (!m) throw new AccountMemberNotFoundError("a1", email);
+        if (m.role === "owner" && ownersLeft() <= 1)
+          throw new LastOwnerError("a1");
+        m.role = "member";
+        return m as never;
+      },
+    },
+    invites: {
+      async create(_a, rawEmail, by) {
+        const email = rawEmail.trim().toLowerCase();
+        const inv = {
+          id: `i${invites.length}`,
+          accountId: "a1",
+          email,
+          invitedBy: by,
+          acceptedAt: null,
+          createdAt: d,
+        };
+        invites = [...invites.filter((i) => i.email !== email), inv];
+        return inv as never;
+      },
+      async listPending() {
+        return invites as never;
+      },
+      async revoke(_a, email) {
+        invites = invites.filter((i) => i.email !== email);
+      },
+    },
+  };
+  const app = new Hono<AdminUIEnv>();
+  registerAccountRoutes(app, deps);
+  return { app, getMembers: () => members, getAccount: () => account };
+}
+
+function post(
+  app: Hono<AdminUIEnv>,
+  path: string,
+  fields: Record<string, string>,
+  email?: string,
+) {
+  return app.request(path, {
+    method: "POST",
+    body: new URLSearchParams(fields).toString(),
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...(email ? { "x-test-user-email": email } : {}),
+    },
+  });
+}
+
+describe("/admin/account", () => {
+  it("returns 404 for every route when the flag is off", async () => {
+    const { app } = setup({ enabled: false });
+    expect((await app.request("/admin/account")).status).toBe(404);
+    expect(
+      (await post(app, "/admin/account/invite", { email: "a@b.co" })).status,
+    ).toBe(404);
+  });
+
+  it("returns 404 for a signed-in user without an account", async () => {
+    const { app } = setup();
+    const res = await app.request("/admin/account", {
+      headers: { "x-test-user-email": "stranger@x.com" },
+    });
+    expect(res.status).toBe(404);
+  });
+
+  it("GET renders the account for a member", async () => {
+    const { app } = setup();
+    const res = await app.request("/admin/account", {
+      headers: { "x-test-user-email": "member@x.com" },
+    });
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain("Acme");
+    expect(body).toContain("1 / 2");
+  });
+
+  it("owner can invite, see it pending, and revoke it", async () => {
+    const { app } = setup();
+    const res = await post(app, "/admin/account/invite", {
+      email: "New@X.com",
+    });
+    expect(res.status).toBe(302);
+    const page = await (await app.request("/admin/account")).text();
+    expect(page).toContain("new@x.com");
+    const rev = await post(app, "/admin/account/invites/revoke", {
+      email: "new@x.com",
+    });
+    expect(rev.status).toBe(302);
+    expect(await (await app.request("/admin/account")).text()).not.toContain(
+      "new@x.com",
+    );
+  });
+
+  it("rejects an invalid or already-member invite email with 400", async () => {
+    const { app } = setup();
+    expect(
+      (await post(app, "/admin/account/invite", { email: "nope" })).status,
+    ).toBe(400);
+    expect(
+      (await post(app, "/admin/account/invite", { email: "member@x.com" }))
+        .status,
+    ).toBe(400);
+  });
+
+  it("member gets 403 on every mutation", async () => {
+    const { app } = setup();
+    for (const [path, fields] of [
+      ["/admin/account/invite", { email: "a@b.co" }],
+      ["/admin/account/invites/revoke", { email: "a@b.co" }],
+      ["/admin/account/members/remove", { email: "owner@x.com" }],
+      ["/admin/account/members/promote", { email: "member@x.com" }],
+      ["/admin/account/members/demote", { email: "owner@x.com" }],
+      ["/admin/account/rename", { name: "X" }],
+    ] as const) {
+      const res = await post(app, path, { ...fields }, "member@x.com");
+      expect(res.status).toBe(403);
+    }
+  });
+
+  it("removing or demoting the last owner shows an error and changes nothing", async () => {
+    const { app, getMembers } = setup();
+    const rm = await post(app, "/admin/account/members/remove", {
+      email: "owner@x.com",
+    });
+    expect(rm.status).toBe(400);
+    expect(await rm.text()).toContain("last owner");
+    const dm = await post(app, "/admin/account/members/demote", {
+      email: "owner@x.com",
+    });
+    expect(dm.status).toBe(400);
+    expect(getMembers().find((m) => m.email === "owner@x.com")?.role).toBe(
+      "owner",
+    );
+    expect(getMembers()).toHaveLength(2);
+  });
+
+  it("owner can promote then remove a member", async () => {
+    const { app, getMembers } = setup();
+    expect(
+      (
+        await post(app, "/admin/account/members/promote", {
+          email: "member@x.com",
+        })
+      ).status,
+    ).toBe(302);
+    expect(getMembers().find((m) => m.email === "member@x.com")?.role).toBe(
+      "owner",
+    );
+    expect(
+      (
+        await post(app, "/admin/account/members/remove", {
+          email: "member@x.com",
+        })
+      ).status,
+    ).toBe(302);
+    expect(getMembers()).toHaveLength(1);
+  });
+
+  it("removing an unknown member returns 404", async () => {
+    const { app } = setup();
+    expect(
+      (
+        await post(app, "/admin/account/members/remove", {
+          email: "ghost@x.com",
+        })
+      ).status,
+    ).toBe(404);
+  });
+
+  it("owner can rename; empty name is 400", async () => {
+    const { app, getAccount } = setup();
+    expect(
+      (await post(app, "/admin/account/rename", { name: " New Name " })).status,
+    ).toBe(302);
+    expect(getAccount().name).toBe("New Name");
+    expect(
+      (await post(app, "/admin/account/rename", { name: "  " })).status,
+    ).toBe(400);
+  });
+});

package/src/admin-ui-account.ts

@@ -0,0 +1,185 @@
+/**
+ * admin/src/admin-ui-account.ts
+ * GET/POST /admin/account — self-serve account management (SSP-3.2): name,
+ * quota, members, pending invites. Owners manage; members are read-only.
+ *
+ * Registered into admin-ui.ts's app via registerAccountRoutes(). Flag-gated:
+ * every route 404s when self-serve is off, and for signed-in users with no
+ * account.
+ */
+
+import type { Context, Hono, MiddlewareHandler } from "hono";
+import type { AccountInviteService } from "./account-invites.ts";
+import {
+  AccountMemberNotFoundError,
+  type AccountMemberService,
+  LastOwnerError,
+} from "./account-members.ts";
+import { normalizeEmail } from "./account-email.ts";
+import type { Account, AccountService } from "./accounts.ts";
+import { ACCOUNT_PATH, renderAccountPage } from "./admin-ui-account-pages.ts";
+import type { AdminUIEnv } from "./admin-ui.ts";
+
+export interface AccountRouteDeps {
+  /** SHIPWRIGHT_SELF_SERVE_ENABLED === "enabled". */
+  enabled: boolean;
+  requireAuth: MiddlewareHandler<AdminUIEnv>;
+  accounts: Pick<AccountService, "getByMemberEmail" | "update" | "countAgents">;
+  members: Pick<
+    AccountMemberService,
+    "listByAccount" | "getByEmail" | "remove" | "promote" | "demote"
+  >;
+  invites: Pick<AccountInviteService, "create" | "listPending" | "revoke">;
+  html: (content: string, opts?: { status?: number }) => Response;
+}
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const MAX_NAME_LENGTH = 100;
+
+export function registerAccountRoutes(
+  app: Hono<AdminUIEnv>,
+  deps: AccountRouteDeps,
+): void {
+  const notFound = () => new Response("Not Found", { status: 404 });
+
+  // Flag-off 404s before auth so the route is indistinguishable from absent.
+  app.use(`${ACCOUNT_PATH}`, async (_c, next) =>
+    deps.enabled ? next() : notFound(),
+  );
+  app.use(`${ACCOUNT_PATH}/*`, async (_c, next) =>
+    deps.enabled ? next() : notFound(),
+  );
+
+  async function render(
+    c: Context<AdminUIEnv>,
+    account: Account,
+    isOwner: boolean,
+    error?: string,
+    status = 200,
+  ): Promise<Response> {
+    const [members, invites, agentCount] = await Promise.all([
+      deps.members.listByAccount(account.id),
+      deps.invites.listPending(account.id),
+      deps.accounts.countAgents(account.id),
+    ]);
+    return deps.html(
+      renderAccountPage({
+        userEmail: c.var.userEmail,
+        account,
+        agentCount,
+        members,
+        invites,
+        isOwner,
+        error,
+      }),
+      { status },
+    );
+  }
+
+  /** Resolves the caller's account + role, or a 404 Response. */
+  async function resolve(
+    c: Context<AdminUIEnv>,
+  ): Promise<{ account: Account; isOwner: boolean } | Response> {
+    const account = await deps.accounts.getByMemberEmail(c.var.userEmail);
+    if (!account) return notFound();
+    const me = await deps.members.getByEmail(c.var.userEmail);
+    return { account, isOwner: me?.role === "owner" };
+  }
+
+  app.get(ACCOUNT_PATH, deps.requireAuth, async (c) => {
+    const ctx = await resolve(c);
+    if (ctx instanceof Response) return ctx;
+    return render(c, ctx.account, ctx.isOwner);
+  });
+
+  /**
+   * Shared shape for owner-only POST actions: resolve + 403 for non-owners,
+   * read one form field, run the action, 302 back on success, or re-render
+   * with the error and a 4xx on a known failure.
+   */
+  function ownerAction(
+    path: string,
+    field: "email" | "name",
+    run: (args: {
+      account: Account;
+      value: string;
+      userEmail: string;
+    }) => Promise<string | undefined>,
+  ): void {
+    app.post(`${ACCOUNT_PATH}/${path}`, deps.requireAuth, async (c) => {
+      const ctx = await resolve(c);
+      if (ctx instanceof Response) return ctx;
+      if (!ctx.isOwner) return new Response("Forbidden", { status: 403 });
+
+      let value = "";
+      try {
+        const form = await c.req.formData();
+        value = (form.get(field)?.toString() ?? "").trim();
+      } catch {
+        // malformed body — treated as an empty value below
+      }
+
+      try {
+        const error = await run({
+          account: ctx.account,
+          value,
+          userEmail: c.var.userEmail,
+        });
+        if (error) return render(c, ctx.account, true, error, 400);
+      } catch (err) {
+        if (err instanceof LastOwnerError) {
+          return render(
+            c,
+            ctx.account,
+            true,
+            "Cannot remove or demote the last owner of the account.",
+            400,
+          );
+        }
+        if (err instanceof AccountMemberNotFoundError) {
+          return render(c, ctx.account, true, "Member not found.", 404);
+        }
+        throw err;
+      }
+      return c.redirect(ACCOUNT_PATH, 302);
+    });
+  }
+
+  ownerAction("invite", "email", async ({ account, value, userEmail }) => {
+    if (!EMAIL_RE.test(value)) return "Enter a valid email address.";
+    if (await deps.members.getByEmail(value)) {
+      return "That email already belongs to an account.";
+    }
+    await deps.invites.create(account.id, value, normalizeEmail(userEmail));
+    return undefined;
+  });
+
+  ownerAction("invites/revoke", "email", async ({ account, value }) => {
+    await deps.invites.revoke(account.id, value);
+    return undefined;
+  });
+
+  ownerAction("members/remove", "email", async ({ account, value }) => {
+    await deps.members.remove(account.id, value);
+    return undefined;
+  });
+
+  ownerAction("members/promote", "email", async ({ account, value }) => {
+    await deps.members.promote(account.id, value);
+    return undefined;
+  });
+
+  ownerAction("members/demote", "email", async ({ account, value }) => {
+    await deps.members.demote(account.id, value);
+    return undefined;
+  });
+
+  ownerAction("rename", "name", async ({ account, value }) => {
+    if (!value) return "Account name is required.";
+    if (value.length > MAX_NAME_LENGTH) {
+      return `Account name must be at most ${MAX_NAME_LENGTH} characters.`;
+    }
+    await deps.accounts.update(account.id, { name: value });
+    return undefined;
+  });
+}

package/src/admin-ui-accounts-pages.ts

@@ -0,0 +1,202 @@
+/**
+ * admin/src/admin-ui-accounts-pages.ts
+ * Render functions for the platform-admin Accounts pages (SSP-5.2). Pure
+ * string -> string; routes live in admin-ui-accounts.ts.
+ */
+
+import type { AccountInvite } from "./account-invites.ts";
+import type { AccountMember } from "./account-members.ts";
+import type { AccountWithCounts } from "./accounts.ts";
+import { renderAdminPage } from "./admin-ui-layout.ts";
+import { escapeHtml, renderAdminToolbar } from "./admin-ui-styles.ts";
+
+export const ADMIN_ACCOUNTS_PATH = "/admin/accounts";
+
+export interface AccountAgentRef {
+  id: string;
+  name: string;
+}
+
+function dateOnly(d: Date | null | undefined): string {
+  return d ? new Date(d).toISOString().slice(0, 10) : "";
+}
+
+function statusBadge(status: string): string {
+  const cls =
+    status === "active"
+      ? "badge-green"
+      : status === "suspended"
+        ? "badge-red"
+        : "badge-gray";
+  return `<span class="badge ${cls}">${escapeHtml(status)}</span>`;
+}
+
+interface AccountsListPageOpts {
+  userEmail: string;
+  accounts: AccountWithCounts[];
+  /** accountId -> owner emails. */
+  owners: Map<string, string[]>;
+}
+
+export function renderAccountsListPage(opts: AccountsListPageOpts): string {
+  const rows =
+    opts.accounts.length === 0
+      ? `<tr><td colspan="8" class="empty-state">No accounts.</td></tr>`
+      : opts.accounts
+          .map((a) => {
+            const owners = opts.owners.get(a.id) ?? [];
+            return `<tr>
+    <td><a href="${ADMIN_ACCOUNTS_PATH}/${escapeHtml(a.id)}" class="agent-link">${escapeHtml(a.name)}</a></td>
+    <td>${owners.length ? owners.map(escapeHtml).join(", ") : "—"}</td>
+    <td>${a.memberCount}</td>
+    <td>${a.agentCount} / ${a.maxAgents}</td>
+    <td>${statusBadge(a.status)}</td>
+    <td>${a.trialExpiresAt ? escapeHtml(dateOnly(a.trialExpiresAt)) : "—"}</td>
+    <td>${escapeHtml(dateOnly(a.createdAt))}</td>
+    <td><a href="${ADMIN_ACCOUNTS_PATH}/${escapeHtml(a.id)}" class="btn btn-secondary" style="font-size:12px;padding:4px 10px">Manage</a></td>
+  </tr>`;
+          })
+          .join("\n");
+
+  return renderAdminPage({
+    title: "Accounts — Shipwright Admin",
+    body: `${renderAdminToolbar(opts.userEmail, ADMIN_ACCOUNTS_PATH)}
+  <div class="vos-page">
+    <div class="page-header"><h1 class="page-title">Accounts</h1></div>
+    <div class="card">
+      <table class="data-table">
+        <thead><tr><th>Name</th><th>Owner</th><th>Members</th><th>Agents</th><th>Status</th><th>Trial expires</th><th>Created</th><th></th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>
+    </div>
+  </div>`,
+  });
+}
+
+interface AccountDetailPageOpts {
+  userEmail: string;
+  account: AccountWithCounts;
+  agents: AccountAgentRef[];
+  members: AccountMember[];
+  invites: AccountInvite[];
+  error?: string;
+}
+
+function postForm(
+  accountId: string,
+  action: string,
+  fields: Record<string, string>,
+  label: string,
+  danger = false,
+): string {
+  const hidden = Object.entries(fields)
+    .map(
+      ([k, v]) =>
+        `<input type="hidden" name="${escapeHtml(k)}" value="${escapeHtml(v)}" />`,
+    )
+    .join("");
+  return `<form method="POST" action="${ADMIN_ACCOUNTS_PATH}/${escapeHtml(accountId)}/${action}" style="display:inline;margin:0">${hidden}
+    <button type="submit" class="btn ${danger ? "btn-danger" : "btn-secondary"}" style="font-size:12px;padding:4px 10px">${label}</button>
+  </form>`;
+}
+
+export function renderAccountDetailPage(opts: AccountDetailPageOpts): string {
+  const { account } = opts;
+  const id = account.id;
+  const base = `${ADMIN_ACCOUNTS_PATH}/${escapeHtml(id)}`;
+  const errorHtml = opts.error
+    ? `<div class="alert alert-error">${escapeHtml(opts.error)}</div>`
+    : "";
+
+  const statusAction =
+    account.status === "active"
+      ? postForm(id, "suspend", {}, "Suspend", true)
+      : postForm(id, "reactivate", {}, "Reactivate");
+
+  const memberRows = opts.members
+    .map(
+      (m) => `<tr>
+    <td>${escapeHtml(m.email)}</td>
+    <td><span class="badge ${m.role === "owner" ? "badge-purple" : "badge-gray"}">${escapeHtml(m.role)}</span></td>
+    <td style="text-align:right">${[
+      m.role === "owner"
+        ? postForm(id, "members/demote", { email: m.email }, "Demote")
+        : postForm(id, "members/promote", { email: m.email }, "Make owner"),
+      postForm(id, "members/remove", { email: m.email }, "Remove", true),
+    ].join(" ")}</td>
+  </tr>`,
+    )
+    .join("\n");
+
+  const agentRows =
+    opts.agents.length === 0
+      ? `<tr><td colspan="2" class="empty-state">No agents.</td></tr>`
+      : opts.agents
+          .map(
+            (a) =>
+              `<tr><td><a href="/admin/agents/${escapeHtml(a.id)}" class="agent-link">${escapeHtml(a.name)}</a></td><td style="text-align:right">${postForm(id, "agents/unassign", { agentId: a.id }, "Unassign", true)}</td></tr>`,
+          )
+          .join("\n");
+
+  const inviteRows =
+    opts.invites.length === 0
+      ? `<tr><td colspan="2" class="empty-state">No pending invites.</td></tr>`
+      : opts.invites
+          .map(
+            (i) =>
+              `<tr><td>${escapeHtml(i.email)}</td><td>${escapeHtml(i.invitedBy)}</td></tr>`,
+          )
+          .join("\n");
+
+  return renderAdminPage({
+    title: `${account.name} — Accounts — Shipwright Admin`,
+    body: `${renderAdminToolbar(opts.userEmail, ADMIN_ACCOUNTS_PATH)}
+  <div class="vos-page">
+    <div class="page-header">
+      <h1 class="page-title">${escapeHtml(account.name)} ${statusBadge(account.status)}</h1>
+      ${statusAction}
+    </div>
+    <p><a href="${ADMIN_ACCOUNTS_PATH}">&larr; All accounts</a></p>
+    ${errorHtml}
+    <div class="card">
+      <div class="card-title">Settings</div>
+      <p>Agents: <strong>${account.agentCount} / ${account.maxAgents}</strong></p>
+      <form method="POST" action="${base}/update" style="display:grid;gap:8px;max-width:360px;margin-top:12px">
+        <label>Name <input name="name" class="form-input" maxlength="100" required value="${escapeHtml(account.name)}" /></label>
+        <label>Max agents <input name="maxAgents" type="number" min="0" step="1" class="form-input" required value="${account.maxAgents}" /></label>
+        <label>Plan <input name="plan" class="form-input" value="${escapeHtml(account.plan ?? "")}" /></label>
+        <label>Trial expires <input name="trialExpiresAt" type="date" class="form-input" value="${escapeHtml(dateOnly(account.trialExpiresAt))}" /></label>
+        <div><button type="submit" class="btn btn-primary">Save</button></div>
+      </form>
+    </div>
+    <div class="card">
+      <div class="card-title">Agents</div>
+      <table class="data-table"><tbody>${agentRows}</tbody></table>
+      <form method="POST" action="${base}/agents/assign" style="display:flex;gap:8px;margin-top:12px">
+        <input name="agentId" class="form-input" required placeholder="Agent ID" style="max-width:280px" />
+        <button type="submit" class="btn btn-primary">Assign agent</button>
+      </form>
+      <p class="help-text" style="font-size:12px;margin-top:8px">Assigning or unassigning an agent updates its scope immediately and re-applies its tenant pod settings. Historical task-store rows (tasks, PRs) are not moved to the new account.</p>
+    </div>
+    <div class="card">
+      <div class="card-title">Members</div>
+      <table class="data-table">
+        <thead><tr><th>Email</th><th>Role</th><th></th></tr></thead>
+        <tbody>${memberRows}</tbody>
+      </table>
+      <form method="POST" action="${base}/members/add" style="display:flex;gap:8px;margin-top:12px">
+        <input name="email" type="email" class="form-input" required placeholder="user@example.com" style="max-width:280px" />
+        <select name="role" class="form-input" style="max-width:120px"><option value="member">member</option><option value="owner">owner</option></select>
+        <button type="submit" class="btn btn-primary">Add</button>
+      </form>
+    </div>
+    <div class="card">
+      <div class="card-title">Pending invites</div>
+      <table class="data-table">
+        <thead><tr><th>Email</th><th>Invited by</th></tr></thead>
+        <tbody>${inviteRows}</tbody>
+      </table>
+    </div>
+  </div>`,
+  });
+}