corporateai 0.0.1

package/ui/src/adapters/transcript.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { buildTranscript, type RunLogChunk } from "./transcript";
+
+describe("buildTranscript", () => {
+  const ts = "2026-03-20T13:00:00.000Z";
+  const chunks: RunLogChunk[] = [
+    { ts, stream: "stdout", chunk: "opened /Users/dotta/project\n" },
+    { ts, stream: "stderr", chunk: "stderr /Users/dotta/project" },
+  ];
+
+  it("defaults username censoring to off when options are omitted", () => {
+    const entries = buildTranscript(chunks, (line, entryTs) => [{ kind: "stdout", ts: entryTs, text: line }]);
+
+    expect(entries).toEqual([
+      { kind: "stdout", ts, text: "opened /Users/dotta/project" },
+      { kind: "stderr", ts, text: "stderr /Users/dotta/project" },
+    ]);
+  });
+
+  it("still redacts usernames when explicitly enabled", () => {
+    const entries = buildTranscript(chunks, (line, entryTs) => [{ kind: "stdout", ts: entryTs, text: line }], {
+      censorUsernameInLogs: true,
+    });
+
+    expect(entries).toEqual([
+      { kind: "stdout", ts, text: "opened /Users/d****/project" },
+      { kind: "stderr", ts, text: "stderr /Users/d****/project" },
+    ]);
+  });
+});

package/ui/src/adapters/transcript.ts

@@ -0,0 +1,62 @@
+import { redactHomePathUserSegments, redactTranscriptEntryPaths } from "@corporateai/adapter-utils";
+import type { TranscriptEntry, StdoutLineParser } from "./types";
+
+export type RunLogChunk = { ts: string; stream: "stdout" | "stderr" | "system"; chunk: string };
+type TranscriptBuildOptions = { censorUsernameInLogs?: boolean };
+
+export function appendTranscriptEntry(entries: TranscriptEntry[], entry: TranscriptEntry) {
+  if ((entry.kind === "thinking" || entry.kind === "assistant") && entry.delta) {
+    const last = entries[entries.length - 1];
+    if (last && last.kind === entry.kind && last.delta) {
+      last.text += entry.text;
+      last.ts = entry.ts;
+      return;
+    }
+  }
+  entries.push(entry);
+}
+
+export function appendTranscriptEntries(entries: TranscriptEntry[], incoming: TranscriptEntry[]) {
+  for (const entry of incoming) {
+    appendTranscriptEntry(entries, entry);
+  }
+}
+
+export function buildTranscript(
+  chunks: RunLogChunk[],
+  parser: StdoutLineParser,
+  opts?: TranscriptBuildOptions,
+): TranscriptEntry[] {
+  const entries: TranscriptEntry[] = [];
+  let stdoutBuffer = "";
+  const redactionOptions = { enabled: opts?.censorUsernameInLogs ?? false };
+
+  for (const chunk of chunks) {
+    if (chunk.stream === "stderr") {
+      entries.push({ kind: "stderr", ts: chunk.ts, text: redactHomePathUserSegments(chunk.chunk, redactionOptions) });
+      continue;
+    }
+    if (chunk.stream === "system") {
+      entries.push({ kind: "system", ts: chunk.ts, text: redactHomePathUserSegments(chunk.chunk, redactionOptions) });
+      continue;
+    }
+
+    const combined = stdoutBuffer + chunk.chunk;
+    const lines = combined.split(/\r?\n/);
+    stdoutBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      appendTranscriptEntries(entries, parser(trimmed, chunk.ts).map((entry) => redactTranscriptEntryPaths(entry, redactionOptions)));
+    }
+  }
+
+  const trailing = stdoutBuffer.trim();
+  if (trailing) {
+    const ts = chunks.length > 0 ? chunks[chunks.length - 1]!.ts : new Date().toISOString();
+    appendTranscriptEntries(entries, parser(trailing, ts).map((entry) => redactTranscriptEntryPaths(entry, redactionOptions)));
+  }
+
+  return entries;
+}
+

package/ui/src/adapters/types.ts

@@ -0,0 +1,34 @@
+import type { ComponentType } from "react";
+import type { CreateConfigValues } from "@corporateai/adapter-utils";
+
+// Re-export shared types so local consumers don't need to change imports
+export type { TranscriptEntry, StdoutLineParser, CreateConfigValues } from "@corporateai/adapter-utils";
+
+export interface AdapterConfigFieldsProps {
+  mode: "create" | "edit";
+  isCreate: boolean;
+  adapterType: string;
+  /** Create mode: raw form values */
+  values: CreateConfigValues | null;
+  /** Create mode: setter for form values */
+  set: ((patch: Partial<CreateConfigValues>) => void) | null;
+  /** Edit mode: original adapterConfig from agent */
+  config: Record<string, unknown>;
+  /** Edit mode: read effective value */
+  eff: <T>(group: "adapterConfig", field: string, original: T) => T;
+  /** Edit mode: mark field dirty */
+  mark: (group: "adapterConfig", field: string, value: unknown) => void;
+  /** Available models for dropdowns */
+  models: { id: string; label: string }[];
+  /** When true, hides the instructions file path field (e.g. during import where it's set automatically) */
+  hideInstructionsFile?: boolean;
+}
+
+export interface UIAdapterModule {
+  type: string;
+  label: string;
+  parseStdoutLine: (line: string, ts: string) => import("@corporateai/adapter-utils").TranscriptEntry[];
+  ConfigFields: ComponentType<AdapterConfigFieldsProps>;
+  buildAdapterConfig: (values: CreateConfigValues) => Record<string, unknown>;
+}
+

package/ui/src/api/access.ts

@@ -0,0 +1,160 @@
+import type { AgentAdapterType, JoinRequest } from "@corporateai/shared";
+import { api } from "./client";
+
+type InviteSummary = {
+  id: string;
+  companyId: string | null;
+  inviteType: "company_join" | "bootstrap_ceo";
+  allowedJoinTypes: "human" | "agent" | "both";
+  expiresAt: string;
+  onboardingPath?: string;
+  onboardingUrl?: string;
+  onboardingTextPath?: string;
+  onboardingTextUrl?: string;
+  skillIndexPath?: string;
+  skillIndexUrl?: string;
+  inviteMessage?: string | null;
+};
+
+type AcceptInviteInput =
+  | { requestType: "human" }
+  | {
+    requestType: "agent";
+    agentName: string;
+    adapterType?: AgentAdapterType;
+    capabilities?: string | null;
+    agentDefaultsPayload?: Record<string, unknown> | null;
+  };
+
+type AgentJoinRequestAccepted = JoinRequest & {
+  claimSecret: string;
+  claimApiKeyPath: string;
+  onboarding?: Record<string, unknown>;
+  diagnostics?: Array<{
+    code: string;
+    level: "info" | "warn";
+    message: string;
+    hint?: string;
+  }>;
+};
+
+type InviteOnboardingManifest = {
+  invite: InviteSummary;
+  onboarding: {
+    inviteMessage?: string | null;
+    connectivity?: {
+      guidance?: string;
+      connectionCandidates?: string[];
+      testResolutionEndpoint?: {
+        method?: string;
+        path?: string;
+        url?: string;
+      };
+    };
+    textInstructions?: {
+      url?: string;
+    };
+  };
+};
+
+type BoardClaimStatus = {
+  status: "available" | "claimed" | "expired";
+  requiresSignIn: boolean;
+  expiresAt: string | null;
+  claimedByUserId: string | null;
+};
+
+type CliAuthChallengeStatus = {
+  id: string;
+  status: "pending" | "approved" | "cancelled" | "expired";
+  command: string;
+  clientName: string | null;
+  requestedAccess: "board" | "instance_admin_required";
+  requestedCompanyId: string | null;
+  requestedCompanyName: string | null;
+  approvedAt: string | null;
+  cancelledAt: string | null;
+  expiresAt: string;
+  approvedByUser: { id: string; name: string; email: string } | null;
+  requiresSignIn: boolean;
+  canApprove: boolean;
+  currentUserId: string | null;
+};
+
+type CompanyInviteCreated = {
+  id: string;
+  token: string;
+  inviteUrl: string;
+  expiresAt: string;
+  allowedJoinTypes: "human" | "agent" | "both";
+  onboardingTextPath?: string;
+  onboardingTextUrl?: string;
+  inviteMessage?: string | null;
+};
+
+export const accessApi = {
+  createCompanyInvite: (
+    companyId: string,
+    input: {
+      allowedJoinTypes?: "human" | "agent" | "both";
+      defaultsPayload?: Record<string, unknown> | null;
+      agentMessage?: string | null;
+    } = {},
+  ) =>
+    api.post<CompanyInviteCreated>(`/companies/${companyId}/invites`, input),
+
+  createOpenClawInvitePrompt: (
+    companyId: string,
+    input: {
+      agentMessage?: string | null;
+    } = {},
+  ) =>
+    api.post<CompanyInviteCreated>(
+      `/companies/${companyId}/openclaw/invite-prompt`,
+      input,
+    ),
+
+  getInvite: (token: string) => api.get<InviteSummary>(`/invites/${token}`),
+  getInviteOnboarding: (token: string) =>
+    api.get<InviteOnboardingManifest>(`/invites/${token}/onboarding`),
+
+  acceptInvite: (token: string, input: AcceptInviteInput) =>
+    api.post<AgentJoinRequestAccepted | JoinRequest | { bootstrapAccepted: true; userId: string }>(
+      `/invites/${token}/accept`,
+      input,
+    ),
+
+  listJoinRequests: (companyId: string, status: "pending_approval" | "approved" | "rejected" = "pending_approval") =>
+    api.get<JoinRequest[]>(`/companies/${companyId}/join-requests?status=${status}`),
+
+  approveJoinRequest: (companyId: string, requestId: string) =>
+    api.post<JoinRequest>(`/companies/${companyId}/join-requests/${requestId}/approve`, {}),
+
+  rejectJoinRequest: (companyId: string, requestId: string) =>
+    api.post<JoinRequest>(`/companies/${companyId}/join-requests/${requestId}/reject`, {}),
+
+  claimJoinRequestApiKey: (requestId: string, claimSecret: string) =>
+    api.post<{ keyId: string; token: string; agentId: string; createdAt: string }>(
+      `/join-requests/${requestId}/claim-api-key`,
+      { claimSecret },
+    ),
+
+  getBoardClaimStatus: (token: string, code: string) =>
+    api.get<BoardClaimStatus>(`/board-claim/${token}?code=${encodeURIComponent(code)}`),
+
+  claimBoard: (token: string, code: string) =>
+    api.post<{ claimed: true; userId: string }>(`/board-claim/${token}/claim`, { code }),
+
+  getCliAuthChallenge: (id: string, token: string) =>
+    api.get<CliAuthChallengeStatus>(`/cli-auth/challenges/${id}?token=${encodeURIComponent(token)}`),
+
+  approveCliAuthChallenge: (id: string, token: string) =>
+    api.post<{ approved: boolean; status: string; userId: string; keyId: string | null; expiresAt: string }>(
+      `/cli-auth/challenges/${id}/approve`,
+      { token },
+    ),
+
+  cancelCliAuthChallenge: (id: string, token: string) =>
+    api.post<{ cancelled: boolean; status: string }>(`/cli-auth/challenges/${id}/cancel`, { token }),
+};
+

package/ui/src/api/activity.ts

@@ -0,0 +1,37 @@
+import type { ActivityEvent } from "@corporateai/shared";
+import { api } from "./client";
+
+export interface RunForIssue {
+  runId: string;
+  status: string;
+  agentId: string;
+  startedAt: string | null;
+  finishedAt: string | null;
+  createdAt: string;
+  invocationSource: string;
+  usageJson: Record<string, unknown> | null;
+  resultJson: Record<string, unknown> | null;
+}
+
+export interface IssueForRun {
+  issueId: string;
+  identifier: string | null;
+  title: string;
+  status: string;
+  priority: string;
+}
+
+export const activityApi = {
+  list: (companyId: string, filters?: { entityType?: string; entityId?: string; agentId?: string }) => {
+    const params = new URLSearchParams();
+    if (filters?.entityType) params.set("entityType", filters.entityType);
+    if (filters?.entityId) params.set("entityId", filters.entityId);
+    if (filters?.agentId) params.set("agentId", filters.agentId);
+    const qs = params.toString();
+    return api.get<ActivityEvent[]>(`/companies/${companyId}/activity${qs ? `?${qs}` : ""}`);
+  },
+  forIssue: (issueId: string) => api.get<ActivityEvent[]>(`/issues/${issueId}/activity`),
+  runsForIssue: (issueId: string) => api.get<RunForIssue[]>(`/issues/${issueId}/runs`),
+  issuesForRun: (runId: string) => api.get<IssueForRun[]>(`/heartbeat-runs/${runId}/issues`),
+};
+

package/ui/src/api/agents.ts

@@ -0,0 +1,194 @@
+import type {
+  Agent,
+  AgentDetail,
+  AgentInstructionsBundle,
+  AgentInstructionsFileDetail,
+  AgentSkillSnapshot,
+  AdapterEnvironmentTestResult,
+  AgentKeyCreated,
+  AgentRuntimeState,
+  AgentTaskSession,
+  HeartbeatRun,
+  Approval,
+  AgentConfigRevision,
+} from "@corporateai/shared";
+import { isUuidLike, normalizeAgentUrlKey } from "@corporateai/shared";
+import { ApiError, api } from "./client";
+
+export interface AgentKey {
+  id: string;
+  name: string;
+  createdAt: Date;
+  revokedAt: Date | null;
+}
+
+export interface AdapterModel {
+  id: string;
+  label: string;
+}
+
+export interface ClaudeLoginResult {
+  exitCode: number | null;
+  signal: string | null;
+  timedOut: boolean;
+  loginUrl: string | null;
+  stdout: string;
+  stderr: string;
+}
+
+export interface OrgNode {
+  id: string;
+  name: string;
+  role: string;
+  status: string;
+  reports: OrgNode[];
+}
+
+export interface AgentHireResponse {
+  agent: Agent;
+  approval: Approval | null;
+}
+
+export interface AgentPermissionUpdate {
+  canCreateAgents: boolean;
+  canAssignTasks: boolean;
+}
+
+function withCompanyScope(path: string, companyId?: string) {
+  if (!companyId) return path;
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}companyId=${encodeURIComponent(companyId)}`;
+}
+
+function agentPath(id: string, companyId?: string, suffix = "") {
+  return withCompanyScope(`/agents/${encodeURIComponent(id)}${suffix}`, companyId);
+}
+
+export const agentsApi = {
+  list: (companyId: string) => api.get<Agent[]>(`/companies/${companyId}/agents`),
+  org: (companyId: string) => api.get<OrgNode[]>(`/companies/${companyId}/org`),
+  listConfigurations: (companyId: string) =>
+    api.get<Record<string, unknown>[]>(`/companies/${companyId}/agent-configurations`),
+  get: async (id: string, companyId?: string) => {
+    try {
+      return await api.get<AgentDetail>(agentPath(id, companyId));
+    } catch (error) {
+      // Backward-compat fallback: if backend shortname lookup reports ambiguity,
+      // resolve using company agent list while ignoring terminated agents.
+      if (
+        !(error instanceof ApiError) ||
+        error.status !== 409 ||
+        !companyId ||
+        isUuidLike(id)
+      ) {
+        throw error;
+      }
+
+      const urlKey = normalizeAgentUrlKey(id);
+      if (!urlKey) throw error;
+
+      const agents = await api.get<Agent[]>(`/companies/${companyId}/agents`);
+      const matches = agents.filter(
+        (agent) => agent.status !== "terminated" && normalizeAgentUrlKey(agent.urlKey) === urlKey,
+      );
+      if (matches.length !== 1) throw error;
+      return api.get<AgentDetail>(agentPath(matches[0]!.id, companyId));
+    }
+  },
+  getConfiguration: (id: string, companyId?: string) =>
+    api.get<Record<string, unknown>>(agentPath(id, companyId, "/configuration")),
+  listConfigRevisions: (id: string, companyId?: string) =>
+    api.get<AgentConfigRevision[]>(agentPath(id, companyId, "/config-revisions")),
+  getConfigRevision: (id: string, revisionId: string, companyId?: string) =>
+    api.get<AgentConfigRevision>(agentPath(id, companyId, `/config-revisions/${revisionId}`)),
+  rollbackConfigRevision: (id: string, revisionId: string, companyId?: string) =>
+    api.post<Agent>(agentPath(id, companyId, `/config-revisions/${revisionId}/rollback`), {}),
+  create: (companyId: string, data: Record<string, unknown>) =>
+    api.post<Agent>(`/companies/${companyId}/agents`, data),
+  hire: (companyId: string, data: Record<string, unknown>) =>
+    api.post<AgentHireResponse>(`/companies/${companyId}/agent-hires`, data),
+  update: (id: string, data: Record<string, unknown>, companyId?: string) =>
+    api.patch<Agent>(agentPath(id, companyId), data),
+  updatePermissions: (id: string, data: AgentPermissionUpdate, companyId?: string) =>
+    api.patch<AgentDetail>(agentPath(id, companyId, "/permissions"), data),
+  instructionsBundle: (id: string, companyId?: string) =>
+    api.get<AgentInstructionsBundle>(agentPath(id, companyId, "/instructions-bundle")),
+  updateInstructionsBundle: (
+    id: string,
+    data: {
+      mode?: "managed" | "external";
+      rootPath?: string | null;
+      entryFile?: string;
+      clearLegacyPromptTemplate?: boolean;
+    },
+    companyId?: string,
+  ) => api.patch<AgentInstructionsBundle>(agentPath(id, companyId, "/instructions-bundle"), data),
+  instructionsFile: (id: string, relativePath: string, companyId?: string) =>
+    api.get<AgentInstructionsFileDetail>(
+      agentPath(id, companyId, `/instructions-bundle/file?path=${encodeURIComponent(relativePath)}`),
+    ),
+  saveInstructionsFile: (
+    id: string,
+    data: { path: string; content: string; clearLegacyPromptTemplate?: boolean },
+    companyId?: string,
+  ) => api.put<AgentInstructionsFileDetail>(agentPath(id, companyId, "/instructions-bundle/file"), data),
+  deleteInstructionsFile: (id: string, relativePath: string, companyId?: string) =>
+    api.delete<AgentInstructionsBundle>(
+      agentPath(id, companyId, `/instructions-bundle/file?path=${encodeURIComponent(relativePath)}`),
+    ),
+  pause: (id: string, companyId?: string) => api.post<Agent>(agentPath(id, companyId, "/pause"), {}),
+  resume: (id: string, companyId?: string) => api.post<Agent>(agentPath(id, companyId, "/resume"), {}),
+  terminate: (id: string, companyId?: string) => api.post<Agent>(agentPath(id, companyId, "/terminate"), {}),
+  remove: (id: string, companyId?: string) => api.delete<{ ok: true }>(agentPath(id, companyId)),
+  listKeys: (id: string, companyId?: string) => api.get<AgentKey[]>(agentPath(id, companyId, "/keys")),
+  skills: (id: string, companyId?: string) =>
+    api.get<AgentSkillSnapshot>(agentPath(id, companyId, "/skills")),
+  syncSkills: (id: string, desiredSkills: string[], companyId?: string) =>
+    api.post<AgentSkillSnapshot>(agentPath(id, companyId, "/skills/sync"), { desiredSkills }),
+  createKey: (id: string, name: string, companyId?: string) =>
+    api.post<AgentKeyCreated>(agentPath(id, companyId, "/keys"), { name }),
+  revokeKey: (agentId: string, keyId: string, companyId?: string) =>
+    api.delete<{ ok: true }>(agentPath(agentId, companyId, `/keys/${encodeURIComponent(keyId)}`)),
+  runtimeState: (id: string, companyId?: string) =>
+    api.get<AgentRuntimeState>(agentPath(id, companyId, "/runtime-state")),
+  taskSessions: (id: string, companyId?: string) =>
+    api.get<AgentTaskSession[]>(agentPath(id, companyId, "/task-sessions")),
+  resetSession: (id: string, taskKey?: string | null, companyId?: string) =>
+    api.post<void>(agentPath(id, companyId, "/runtime-state/reset-session"), { taskKey: taskKey ?? null }),
+  adapterModels: (companyId: string, type: string) =>
+    api.get<AdapterModel[]>(
+      `/companies/${encodeURIComponent(companyId)}/adapters/${encodeURIComponent(type)}/models`,
+    ),
+  testEnvironment: (
+    companyId: string,
+    type: string,
+    data: { adapterConfig: Record<string, unknown> },
+  ) =>
+    api.post<AdapterEnvironmentTestResult>(
+      `/companies/${companyId}/adapters/${type}/test-environment`,
+      data,
+    ),
+  invoke: (id: string, companyId?: string) => api.post<HeartbeatRun>(agentPath(id, companyId, "/heartbeat/invoke"), {}),
+  wakeup: (
+    id: string,
+    data: {
+      source?: "timer" | "assignment" | "on_demand" | "automation";
+      triggerDetail?: "manual" | "ping" | "callback" | "system";
+      reason?: string | null;
+      payload?: Record<string, unknown> | null;
+      idempotencyKey?: string | null;
+    },
+    companyId?: string,
+  ) => api.post<HeartbeatRun | { status: "skipped" }>(agentPath(id, companyId, "/wakeup"), data),
+  loginWithClaude: (id: string, companyId?: string) =>
+    api.post<ClaudeLoginResult>(agentPath(id, companyId, "/claude-login"), {}),
+  availableSkills: () =>
+    api.get<{ skills: AvailableSkill[] }>("/skills/available"),
+};
+
+export interface AvailableSkill {
+  name: string;
+  description: string;
+  isPaperclipManaged: boolean;
+}
+

package/ui/src/api/approvals.ts

@@ -0,0 +1,25 @@
+import type { Approval, ApprovalComment, Issue } from "@corporateai/shared";
+import { api } from "./client";
+
+export const approvalsApi = {
+  list: (companyId: string, status?: string) =>
+    api.get<Approval[]>(
+      `/companies/${companyId}/approvals${status ? `?status=${encodeURIComponent(status)}` : ""}`,
+    ),
+  create: (companyId: string, data: Record<string, unknown>) =>
+    api.post<Approval>(`/companies/${companyId}/approvals`, data),
+  get: (id: string) => api.get<Approval>(`/approvals/${id}`),
+  approve: (id: string, decisionNote?: string) =>
+    api.post<Approval>(`/approvals/${id}/approve`, { decisionNote }),
+  reject: (id: string, decisionNote?: string) =>
+    api.post<Approval>(`/approvals/${id}/reject`, { decisionNote }),
+  requestRevision: (id: string, decisionNote?: string) =>
+    api.post<Approval>(`/approvals/${id}/request-revision`, { decisionNote }),
+  resubmit: (id: string, payload?: Record<string, unknown>) =>
+    api.post<Approval>(`/approvals/${id}/resubmit`, { payload }),
+  listComments: (id: string) => api.get<ApprovalComment[]>(`/approvals/${id}/comments`),
+  addComment: (id: string, body: string) =>
+    api.post<ApprovalComment>(`/approvals/${id}/comments`, { body }),
+  listIssues: (id: string) => api.get<Issue[]>(`/approvals/${id}/issues`),
+};
+

package/ui/src/api/assets.ts

@@ -0,0 +1,30 @@
+import type { AssetImage } from "@corporateai/shared";
+import { api } from "./client";
+
+export const assetsApi = {
+  uploadImage: async (companyId: string, file: File, namespace?: string) => {
+    // Read file data into memory eagerly so the fetch body is self-contained.
+    // Clipboard-paste File objects reference transient data that the browser may
+    // discard after the paste-event handler returns, causing ERR_ACCESS_DENIED
+    // when fetch() later tries to stream the FormData body.
+    const buffer = await file.arrayBuffer();
+    const safeFile = new File([buffer], file.name, { type: file.type });
+
+    const form = new FormData();
+    if (namespace && namespace.trim().length > 0) {
+      form.append("namespace", namespace.trim());
+    }
+    form.append("file", safeFile);
+    return api.postForm<AssetImage>(`/companies/${companyId}/assets/images`, form);
+  },
+
+  uploadCompanyLogo: async (companyId: string, file: File) => {
+    const buffer = await file.arrayBuffer();
+    const safeFile = new File([buffer], file.name, { type: file.type });
+
+    const form = new FormData();
+    form.append("file", safeFile);
+    return api.postForm<AssetImage>(`/companies/${companyId}/logo`, form);
+  },
+};
+

package/ui/src/api/auth.ts

@@ -0,0 +1,74 @@
+export type AuthSession = {
+  session: { id: string; userId: string };
+  user: { id: string; email: string | null; name: string | null };
+};
+
+function toSession(value: unknown): AuthSession | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as Record<string, unknown>;
+  const sessionValue = record.session;
+  const userValue = record.user;
+  if (!sessionValue || typeof sessionValue !== "object") return null;
+  if (!userValue || typeof userValue !== "object") return null;
+  const session = sessionValue as Record<string, unknown>;
+  const user = userValue as Record<string, unknown>;
+  if (typeof session.id !== "string" || typeof session.userId !== "string") return null;
+  if (typeof user.id !== "string") return null;
+  return {
+    session: { id: session.id, userId: session.userId },
+    user: {
+      id: user.id,
+      email: typeof user.email === "string" ? user.email : null,
+      name: typeof user.name === "string" ? user.name : null,
+    },
+  };
+}
+
+async function authPost(path: string, body: Record<string, unknown>) {
+  const res = await fetch(`/api/auth${path}`, {
+    method: "POST",
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = await res.json().catch(() => null);
+  if (!res.ok) {
+    const message =
+      (payload as { error?: { message?: string } | string } | null)?.error &&
+      typeof (payload as { error?: { message?: string } | string }).error === "object"
+        ? ((payload as { error?: { message?: string } }).error?.message ?? `Request failed: ${res.status}`)
+        : (payload as { error?: string } | null)?.error ?? `Request failed: ${res.status}`;
+    throw new Error(message);
+  }
+  return payload;
+}
+
+export const authApi = {
+  getSession: async (): Promise<AuthSession | null> => {
+    const res = await fetch("/api/auth/get-session", {
+      credentials: "include",
+      headers: { Accept: "application/json" },
+    });
+    if (res.status === 401) return null;
+    const payload = await res.json().catch(() => null);
+    if (!res.ok) {
+      throw new Error(`Failed to load session (${res.status})`);
+    }
+    const direct = toSession(payload);
+    if (direct) return direct;
+    const nested = payload && typeof payload === "object" ? toSession((payload as Record<string, unknown>).data) : null;
+    return nested;
+  },
+
+  signInEmail: async (input: { email: string; password: string }) => {
+    await authPost("/sign-in/email", input);
+  },
+
+  signUpEmail: async (input: { name: string; email: string; password: string }) => {
+    await authPost("/sign-up/email", input);
+  },
+
+  signOut: async () => {
+    await authPost("/sign-out", {});
+  },
+};

package/ui/src/api/budgets.ts

@@ -0,0 +1,21 @@
+import type {
+  BudgetIncident,
+  BudgetIncidentResolutionInput,
+  BudgetOverview,
+  BudgetPolicySummary,
+  BudgetPolicyUpsertInput,
+} from "@corporateai/shared";
+import { api } from "./client";
+
+export const budgetsApi = {
+  overview: (companyId: string) =>
+    api.get<BudgetOverview>(`/companies/${companyId}/budgets/overview`),
+  upsertPolicy: (companyId: string, data: BudgetPolicyUpsertInput) =>
+    api.post<BudgetPolicySummary>(`/companies/${companyId}/budgets/policies`, data),
+  resolveIncident: (companyId: string, incidentId: string, data: BudgetIncidentResolutionInput) =>
+    api.post<BudgetIncident>(
+      `/companies/${companyId}/budget-incidents/${encodeURIComponent(incidentId)}/resolve`,
+      data,
+    ),
+};
+