corporateai 0.0.1

package/ui/src/lib/onboarding-goal.ts

@@ -0,0 +1,18 @@
+export function parseOnboardingGoalInput(raw: string): {
+  title: string;
+  description: string | null;
+} {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return { title: "", description: null };
+  }
+
+  const [firstLine, ...restLines] = trimmed.split(/\r?\n/);
+  const title = firstLine.trim();
+  const description = restLines.join("\n").trim();
+
+  return {
+    title,
+    description: description.length > 0 ? description : null,
+  };
+}

package/ui/src/lib/onboarding-launch.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildOnboardingIssuePayload,
+  buildOnboardingProjectPayload,
+  selectDefaultCompanyGoalId,
+} from "./onboarding-launch";
+
+describe("selectDefaultCompanyGoalId", () => {
+  it("prefers the earliest active root company goal", () => {
+    expect(
+      selectDefaultCompanyGoalId([
+        {
+          id: "team-goal",
+          companyId: "company-1",
+          title: "Nested",
+          description: null,
+          level: "team",
+          status: "active",
+          parentId: null,
+          ownerAgentId: null,
+          createdAt: new Date("2026-03-04T00:00:00Z"),
+          updatedAt: new Date("2026-03-04T00:00:00Z"),
+        },
+        {
+          id: "goal-2",
+          companyId: "company-1",
+          title: "Later active root",
+          description: null,
+          level: "company",
+          status: "active",
+          parentId: null,
+          ownerAgentId: null,
+          createdAt: new Date("2026-03-03T00:00:00Z"),
+          updatedAt: new Date("2026-03-03T00:00:00Z"),
+        },
+        {
+          id: "goal-1",
+          companyId: "company-1",
+          title: "Earliest active root",
+          description: null,
+          level: "company",
+          status: "active",
+          parentId: null,
+          ownerAgentId: null,
+          createdAt: new Date("2026-03-02T00:00:00Z"),
+          updatedAt: new Date("2026-03-02T00:00:00Z"),
+        },
+      ]),
+    ).toBe("goal-1");
+  });
+
+  it("falls back to the earliest root company goal when none are active", () => {
+    expect(
+      selectDefaultCompanyGoalId([
+        {
+          id: "goal-2",
+          companyId: "company-1",
+          title: "Cancelled root",
+          description: null,
+          level: "company",
+          status: "cancelled",
+          parentId: null,
+          ownerAgentId: null,
+          createdAt: new Date("2026-03-03T00:00:00Z"),
+          updatedAt: new Date("2026-03-03T00:00:00Z"),
+        },
+        {
+          id: "goal-1",
+          companyId: "company-1",
+          title: "Earliest root",
+          description: null,
+          level: "company",
+          status: "planned",
+          parentId: null,
+          ownerAgentId: null,
+          createdAt: new Date("2026-03-02T00:00:00Z"),
+          updatedAt: new Date("2026-03-02T00:00:00Z"),
+        },
+      ]),
+    ).toBe("goal-1");
+  });
+});
+
+describe("onboarding launch payloads", () => {
+  it("links the onboarding project and first issue to the selected goal", () => {
+    expect(buildOnboardingProjectPayload("goal-1")).toEqual({
+      name: "Onboarding",
+      status: "in_progress",
+      goalIds: ["goal-1"],
+    });
+
+    expect(
+      buildOnboardingIssuePayload({
+        title: "  Hire your first engineer  ",
+        description: "  Kick off the hiring plan  ",
+        assigneeAgentId: "agent-1",
+        projectId: "project-1",
+        goalId: "goal-1",
+      }),
+    ).toEqual({
+      title: "Hire your first engineer",
+      description: "Kick off the hiring plan",
+      assigneeAgentId: "agent-1",
+      projectId: "project-1",
+      goalId: "goal-1",
+      status: "todo",
+    });
+  });
+
+  it("omits goal links when no default company goal exists", () => {
+    expect(buildOnboardingProjectPayload(null)).toEqual({
+      name: "Onboarding",
+      status: "in_progress",
+    });
+
+    expect(
+      buildOnboardingIssuePayload({
+        title: "Task",
+        description: "",
+        assigneeAgentId: "agent-1",
+        projectId: "project-1",
+        goalId: null,
+      }),
+    ).toEqual({
+      title: "Task",
+      assigneeAgentId: "agent-1",
+      projectId: "project-1",
+      status: "todo",
+    });
+  });
+});

package/ui/src/lib/onboarding-launch.ts

@@ -0,0 +1,54 @@
+import type { Goal } from "@corporateai/shared";
+
+export const ONBOARDING_PROJECT_NAME = "Onboarding";
+
+function goalCreatedAt(goal: Goal) {
+  const createdAt = goal.createdAt instanceof Date ? goal.createdAt : new Date(goal.createdAt);
+  return Number.isNaN(createdAt.getTime()) ? 0 : createdAt.getTime();
+}
+
+function pickEarliestGoal(goals: Goal[]) {
+  return [...goals].sort((a, b) => goalCreatedAt(a) - goalCreatedAt(b))[0] ?? null;
+}
+
+export function selectDefaultCompanyGoalId(goals: Goal[]): string | null {
+  const companyGoals = goals.filter((goal) => goal.level === "company");
+  const rootGoals = companyGoals.filter((goal) => !goal.parentId);
+  const activeRootGoals = rootGoals.filter((goal) => goal.status === "active");
+
+  return (
+    pickEarliestGoal(activeRootGoals)?.id ??
+    pickEarliestGoal(rootGoals)?.id ??
+    pickEarliestGoal(companyGoals)?.id ??
+    null
+  );
+}
+
+export function buildOnboardingProjectPayload(goalId: string | null) {
+  return {
+    name: ONBOARDING_PROJECT_NAME,
+    status: "in_progress" as const,
+    ...(goalId ? { goalIds: [goalId] } : {}),
+  };
+}
+
+export function buildOnboardingIssuePayload(input: {
+  title: string;
+  description: string;
+  assigneeAgentId: string;
+  projectId: string;
+  goalId: string | null;
+}) {
+  const title = input.title.trim();
+  const description = input.description.trim();
+
+  return {
+    title,
+    ...(description ? { description } : {}),
+    assigneeAgentId: input.assigneeAgentId,
+    projectId: input.projectId,
+    ...(input.goalId ? { goalId: input.goalId } : {}),
+    status: "todo" as const,
+  };
+}
+

package/ui/src/lib/onboarding-route.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import {
+  isOnboardingPath,
+  resolveRouteOnboardingOptions,
+  shouldRedirectCompanylessRouteToOnboarding,
+} from "./onboarding-route";
+
+describe("isOnboardingPath", () => {
+  it("matches the global onboarding route", () => {
+    expect(isOnboardingPath("/onboarding")).toBe(true);
+  });
+
+  it("matches a company-prefixed onboarding route", () => {
+    expect(isOnboardingPath("/pap/onboarding")).toBe(true);
+  });
+
+  it("ignores non-onboarding routes", () => {
+    expect(isOnboardingPath("/pap/dashboard")).toBe(false);
+  });
+});
+
+describe("resolveRouteOnboardingOptions", () => {
+  it("opens company creation for the global onboarding route", () => {
+    expect(
+      resolveRouteOnboardingOptions({
+        pathname: "/onboarding",
+        companies: [],
+      }),
+    ).toEqual({ initialStep: 1 });
+  });
+
+  it("opens agent creation when the prefixed company exists", () => {
+    expect(
+      resolveRouteOnboardingOptions({
+        pathname: "/pap/onboarding",
+        companyPrefix: "pap",
+        companies: [{ id: "company-1", issuePrefix: "PAP" }],
+      }),
+    ).toEqual({ initialStep: 2, companyId: "company-1" });
+  });
+
+  it("falls back to company creation when the prefixed company is missing", () => {
+    expect(
+      resolveRouteOnboardingOptions({
+        pathname: "/pap/onboarding",
+        companyPrefix: "pap",
+        companies: [],
+      }),
+    ).toEqual({ initialStep: 1 });
+  });
+});
+
+describe("shouldRedirectCompanylessRouteToOnboarding", () => {
+  it("redirects companyless entry routes into onboarding", () => {
+    expect(
+      shouldRedirectCompanylessRouteToOnboarding({
+        pathname: "/",
+        hasCompanies: false,
+      }),
+    ).toBe(true);
+  });
+
+  it("does not redirect when already on onboarding", () => {
+    expect(
+      shouldRedirectCompanylessRouteToOnboarding({
+        pathname: "/onboarding",
+        hasCompanies: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("does not redirect when companies exist", () => {
+    expect(
+      shouldRedirectCompanylessRouteToOnboarding({
+        pathname: "/issues",
+        hasCompanies: true,
+      }),
+    ).toBe(false);
+  });
+});

package/ui/src/lib/onboarding-route.ts

@@ -0,0 +1,51 @@
+type OnboardingRouteCompany = {
+  id: string;
+  issuePrefix: string;
+};
+
+export function isOnboardingPath(pathname: string): boolean {
+  const segments = pathname.split("/").filter(Boolean);
+
+  if (segments.length === 1) {
+    return segments[0]?.toLowerCase() === "onboarding";
+  }
+
+  if (segments.length === 2) {
+    return segments[1]?.toLowerCase() === "onboarding";
+  }
+
+  return false;
+}
+
+export function resolveRouteOnboardingOptions(params: {
+  pathname: string;
+  companyPrefix?: string;
+  companies: OnboardingRouteCompany[];
+}): { initialStep: 1 | 2; companyId?: string } | null {
+  const { pathname, companyPrefix, companies } = params;
+
+  if (!isOnboardingPath(pathname)) return null;
+
+  if (!companyPrefix) {
+    return { initialStep: 1 };
+  }
+
+  const matchedCompany =
+    companies.find(
+      (company) =>
+        company.issuePrefix.toUpperCase() === companyPrefix.toUpperCase(),
+    ) ?? null;
+
+  if (!matchedCompany) {
+    return { initialStep: 1 };
+  }
+
+  return { initialStep: 2, companyId: matchedCompany.id };
+}
+
+export function shouldRedirectCompanylessRouteToOnboarding(params: {
+  pathname: string;
+  hasCompanies: boolean;
+}): boolean {
+  return !params.hasCompanies && !isOnboardingPath(params.pathname);
+}

package/ui/src/lib/portable-files.ts

@@ -0,0 +1,42 @@
+import type { CompanyPortabilityFileEntry } from "@corporateai/shared";
+
+const contentTypeByExtension: Record<string, string> = {
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+};
+
+export function getPortableFileText(entry: CompanyPortabilityFileEntry | null | undefined) {
+  return typeof entry === "string" ? entry : null;
+}
+
+export function getPortableFileContentType(
+  filePath: string,
+  entry: CompanyPortabilityFileEntry | null | undefined,
+) {
+  if (entry && typeof entry === "object" && entry.contentType) return entry.contentType;
+  const extensionIndex = filePath.toLowerCase().lastIndexOf(".");
+  if (extensionIndex === -1) return null;
+  return contentTypeByExtension[filePath.toLowerCase().slice(extensionIndex)] ?? null;
+}
+
+export function getPortableFileDataUrl(
+  filePath: string,
+  entry: CompanyPortabilityFileEntry | null | undefined,
+) {
+  if (!entry || typeof entry === "string") return null;
+  const contentType = getPortableFileContentType(filePath, entry) ?? "application/octet-stream";
+  return `data:${contentType};base64,${entry.data}`;
+}
+
+export function isPortableImageFile(
+  filePath: string,
+  entry: CompanyPortabilityFileEntry | null | undefined,
+) {
+  const contentType = getPortableFileContentType(filePath, entry);
+  return typeof contentType === "string" && contentType.startsWith("image/");
+}
+

package/ui/src/lib/project-order.ts

@@ -0,0 +1,71 @@
+import type { Project } from "@corporateai/shared";
+
+export const PROJECT_ORDER_UPDATED_EVENT = "paperclip:project-order-updated";
+const PROJECT_ORDER_STORAGE_PREFIX = "paperclip.projectOrder";
+const ANONYMOUS_USER_ID = "anonymous";
+
+type ProjectOrderUpdatedDetail = {
+  storageKey: string;
+  orderedIds: string[];
+};
+
+function normalizeIdList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === "string" && item.length > 0);
+}
+
+function resolveUserId(userId: string | null | undefined): string {
+  if (!userId) return ANONYMOUS_USER_ID;
+  const trimmed = userId.trim();
+  return trimmed.length > 0 ? trimmed : ANONYMOUS_USER_ID;
+}
+
+export function getProjectOrderStorageKey(companyId: string, userId: string | null | undefined): string {
+  return `${PROJECT_ORDER_STORAGE_PREFIX}:${companyId}:${resolveUserId(userId)}`;
+}
+
+export function readProjectOrder(storageKey: string): string[] {
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw) return [];
+    return normalizeIdList(JSON.parse(raw));
+  } catch {
+    return [];
+  }
+}
+
+export function writeProjectOrder(storageKey: string, orderedIds: string[]) {
+  const normalized = normalizeIdList(orderedIds);
+  try {
+    localStorage.setItem(storageKey, JSON.stringify(normalized));
+  } catch {
+    // Ignore storage write failures in restricted browser contexts.
+  }
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(
+      new CustomEvent<ProjectOrderUpdatedDetail>(PROJECT_ORDER_UPDATED_EVENT, {
+        detail: { storageKey, orderedIds: normalized },
+      }),
+    );
+  }
+}
+
+export function sortProjectsByStoredOrder(projects: Project[], orderedIds: string[]): Project[] {
+  if (projects.length === 0) return [];
+  if (orderedIds.length === 0) return projects;
+
+  const byId = new Map(projects.map((project) => [project.id, project]));
+  const sorted: Project[] = [];
+
+  for (const id of orderedIds) {
+    const project = byId.get(id);
+    if (!project) continue;
+    sorted.push(project);
+    byId.delete(id);
+  }
+  for (const project of byId.values()) {
+    sorted.push(project);
+  }
+  return sorted;
+}
+

package/ui/src/lib/queryKeys.ts

@@ -0,0 +1,140 @@
+export const queryKeys = {
+  companies: {
+    all: ["companies"] as const,
+    detail: (id: string) => ["companies", id] as const,
+    stats: ["companies", "stats"] as const,
+  },
+  companySkills: {
+    list: (companyId: string) => ["company-skills", companyId] as const,
+    detail: (companyId: string, skillId: string) => ["company-skills", companyId, skillId] as const,
+    updateStatus: (companyId: string, skillId: string) =>
+      ["company-skills", companyId, skillId, "update-status"] as const,
+    file: (companyId: string, skillId: string, relativePath: string) =>
+      ["company-skills", companyId, skillId, "file", relativePath] as const,
+  },
+  agents: {
+    list: (companyId: string) => ["agents", companyId] as const,
+    detail: (id: string) => ["agents", "detail", id] as const,
+    runtimeState: (id: string) => ["agents", "runtime-state", id] as const,
+    taskSessions: (id: string) => ["agents", "task-sessions", id] as const,
+    skills: (id: string) => ["agents", "skills", id] as const,
+    instructionsBundle: (id: string) => ["agents", "instructions-bundle", id] as const,
+    instructionsFile: (id: string, relativePath: string) =>
+      ["agents", "instructions-bundle", id, "file", relativePath] as const,
+    keys: (agentId: string) => ["agents", "keys", agentId] as const,
+    configRevisions: (agentId: string) => ["agents", "config-revisions", agentId] as const,
+    adapterModels: (companyId: string, adapterType: string) =>
+      ["agents", companyId, "adapter-models", adapterType] as const,
+  },
+  issues: {
+    list: (companyId: string) => ["issues", companyId] as const,
+    search: (companyId: string, q: string, projectId?: string) =>
+      ["issues", companyId, "search", q, projectId ?? "__all-projects__"] as const,
+    listAssignedToMe: (companyId: string) => ["issues", companyId, "assigned-to-me"] as const,
+    listMineByMe: (companyId: string) => ["issues", companyId, "mine-by-me"] as const,
+    listTouchedByMe: (companyId: string) => ["issues", companyId, "touched-by-me"] as const,
+    listUnreadTouchedByMe: (companyId: string) => ["issues", companyId, "unread-touched-by-me"] as const,
+    labels: (companyId: string) => ["issues", companyId, "labels"] as const,
+    listByProject: (companyId: string, projectId: string) =>
+      ["issues", companyId, "project", projectId] as const,
+    detail: (id: string) => ["issues", "detail", id] as const,
+    comments: (issueId: string) => ["issues", "comments", issueId] as const,
+    attachments: (issueId: string) => ["issues", "attachments", issueId] as const,
+    documents: (issueId: string) => ["issues", "documents", issueId] as const,
+    documentRevisions: (issueId: string, key: string) => ["issues", "document-revisions", issueId, key] as const,
+    activity: (issueId: string) => ["issues", "activity", issueId] as const,
+    runs: (issueId: string) => ["issues", "runs", issueId] as const,
+    approvals: (issueId: string) => ["issues", "approvals", issueId] as const,
+    liveRuns: (issueId: string) => ["issues", "live-runs", issueId] as const,
+    activeRun: (issueId: string) => ["issues", "active-run", issueId] as const,
+    workProducts: (issueId: string) => ["issues", "work-products", issueId] as const,
+  },
+  routines: {
+    list: (companyId: string) => ["routines", companyId] as const,
+    detail: (id: string) => ["routines", "detail", id] as const,
+    runs: (id: string) => ["routines", "runs", id] as const,
+    activity: (companyId: string, id: string) => ["routines", "activity", companyId, id] as const,
+  },
+  executionWorkspaces: {
+    list: (companyId: string, filters?: Record<string, string | boolean | undefined>) =>
+      ["execution-workspaces", companyId, filters ?? {}] as const,
+    detail: (id: string) => ["execution-workspaces", "detail", id] as const,
+  },
+  projects: {
+    list: (companyId: string) => ["projects", companyId] as const,
+    detail: (id: string) => ["projects", "detail", id] as const,
+  },
+  goals: {
+    list: (companyId: string) => ["goals", companyId] as const,
+    detail: (id: string) => ["goals", "detail", id] as const,
+  },
+  budgets: {
+    overview: (companyId: string) => ["budgets", "overview", companyId] as const,
+  },
+  approvals: {
+    list: (companyId: string, status?: string) =>
+      ["approvals", companyId, status] as const,
+    detail: (approvalId: string) => ["approvals", "detail", approvalId] as const,
+    comments: (approvalId: string) => ["approvals", "comments", approvalId] as const,
+    issues: (approvalId: string) => ["approvals", "issues", approvalId] as const,
+  },
+  access: {
+    joinRequests: (companyId: string, status: string = "pending_approval") =>
+      ["access", "join-requests", companyId, status] as const,
+    invite: (token: string) => ["access", "invite", token] as const,
+  },
+  auth: {
+    session: ["auth", "session"] as const,
+  },
+  instance: {
+    generalSettings: ["instance", "general-settings"] as const,
+    schedulerHeartbeats: ["instance", "scheduler-heartbeats"] as const,
+    experimentalSettings: ["instance", "experimental-settings"] as const,
+  },
+  health: ["health"] as const,
+  secrets: {
+    list: (companyId: string) => ["secrets", companyId] as const,
+    providers: (companyId: string) => ["secret-providers", companyId] as const,
+  },
+  dashboard: (companyId: string) => ["dashboard", companyId] as const,
+  sidebarBadges: (companyId: string) => ["sidebar-badges", companyId] as const,
+  activity: (companyId: string) => ["activity", companyId] as const,
+  costs: (companyId: string, from?: string, to?: string) =>
+    ["costs", companyId, from, to] as const,
+  usageByProvider: (companyId: string, from?: string, to?: string) =>
+    ["usage-by-provider", companyId, from, to] as const,
+  usageByBiller: (companyId: string, from?: string, to?: string) =>
+    ["usage-by-biller", companyId, from, to] as const,
+  financeSummary: (companyId: string, from?: string, to?: string) =>
+    ["finance-summary", companyId, from, to] as const,
+  financeByBiller: (companyId: string, from?: string, to?: string) =>
+    ["finance-by-biller", companyId, from, to] as const,
+  financeByKind: (companyId: string, from?: string, to?: string) =>
+    ["finance-by-kind", companyId, from, to] as const,
+  financeEvents: (companyId: string, from?: string, to?: string, limit: number = 100) =>
+    ["finance-events", companyId, from, to, limit] as const,
+  usageWindowSpend: (companyId: string) =>
+    ["usage-window-spend", companyId] as const,
+  usageQuotaWindows: (companyId: string) =>
+    ["usage-quota-windows", companyId] as const,
+  heartbeats: (companyId: string, agentId?: string) =>
+    ["heartbeats", companyId, agentId] as const,
+  runDetail: (runId: string) => ["heartbeat-run", runId] as const,
+  runWorkspaceOperations: (runId: string) => ["heartbeat-run", runId, "workspace-operations"] as const,
+  liveRuns: (companyId: string) => ["live-runs", companyId] as const,
+  runIssues: (runId: string) => ["run-issues", runId] as const,
+  org: (companyId: string) => ["org", companyId] as const,
+  skills: {
+    available: ["skills", "available"] as const,
+  },
+  plugins: {
+    all: ["plugins"] as const,
+    examples: ["plugins", "examples"] as const,
+    detail: (pluginId: string) => ["plugins", pluginId] as const,
+    health: (pluginId: string) => ["plugins", pluginId, "health"] as const,
+    uiContributions: ["plugins", "ui-contributions"] as const,
+    config: (pluginId: string) => ["plugins", pluginId, "config"] as const,
+    dashboard: (pluginId: string) => ["plugins", pluginId, "dashboard"] as const,
+    logs: (pluginId: string) => ["plugins", pluginId, "logs"] as const,
+  },
+};

package/ui/src/lib/recent-assignees.ts

@@ -0,0 +1,36 @@
+const STORAGE_KEY = "paperclip:recent-assignees";
+const MAX_RECENT = 10;
+
+export function getRecentAssigneeIds(): string[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function trackRecentAssignee(agentId: string): void {
+  if (!agentId) return;
+  const recent = getRecentAssigneeIds().filter((id) => id !== agentId);
+  recent.unshift(agentId);
+  if (recent.length > MAX_RECENT) recent.length = MAX_RECENT;
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(recent));
+}
+
+export function sortAgentsByRecency<T extends { id: string; name: string }>(
+  agents: T[],
+  recentIds: string[],
+): T[] {
+  const recentIndex = new Map(recentIds.map((id, i) => [id, i]));
+  return [...agents].sort((a, b) => {
+    const aRecent = recentIndex.get(a.id);
+    const bRecent = recentIndex.get(b.id);
+    if (aRecent !== undefined && bRecent !== undefined) return aRecent - bRecent;
+    if (aRecent !== undefined) return -1;
+    if (bRecent !== undefined) return 1;
+    return a.name.localeCompare(b.name);
+  });
+}