@cat-factory/app 0.6.0

package/app/stores/accounts.ts

@@ -0,0 +1,152 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  Account,
+  AccountInvitation,
+  AccountMember,
+  AccountRole,
+  CloudProvider,
+  EmailConnection,
+} from '~/types/domain'
+
+/**
+ * Account tenancy on the client: the accounts the signed-in user can switch
+ * between (their personal account plus any orgs they belong to) and which one is
+ * active. The active account scopes the board switcher and stamps new boards, so
+ * a team can keep org boards separate from personal ones.
+ *
+ * Empty when auth is disabled (the backend returns no accounts in dev), in which
+ * case the UI simply hides the account switcher and boards stay unscoped.
+ */
+export const useAccountsStore = defineStore(
+  'accounts',
+  () => {
+    const api = useApi()
+
+    const accounts = ref<Account[]>([])
+    /** Active account id (persisted so a reload keeps the same context). */
+    const activeAccountId = ref<string | null>(null)
+    const ready = ref(false)
+
+    const activeAccount = computed(
+      () => accounts.value.find((a) => a.id === activeAccountId.value) ?? null,
+    )
+    /** Whether accounts exist (auth on); gates the switcher UI. */
+    const enabled = computed(() => accounts.value.length > 0)
+
+    /** Load the user's accounts and resolve the active one (persisted or first). */
+    async function load() {
+      accounts.value = await api.listAccounts()
+      if (!activeAccountId.value || !accounts.value.some((a) => a.id === activeAccountId.value)) {
+        activeAccountId.value = accounts.value[0]?.id ?? null
+      }
+      ready.value = true
+    }
+
+    /** Create a shared org account and make it active. */
+    async function createOrg(name: string) {
+      const account = await api.createAccount({ name })
+      accounts.value.push(account)
+      activeAccountId.value = account.id
+      return account
+    }
+
+    /** Switch the active account (the caller re-scopes the board list). */
+    function switchTo(id: string) {
+      activeAccountId.value = id
+    }
+
+    /**
+     * Set an account's default cloud provider (the provider new services inherit).
+     * Owner-only on the backend; patches the loaded account in place on success.
+     */
+    async function setDefaultCloudProvider(id: string, provider: CloudProvider) {
+      const updated = await api.updateAccount(id, { defaultCloudProvider: provider })
+      const i = accounts.value.findIndex((a) => a.id === id)
+      if (i >= 0) accounts.value[i] = updated
+      return updated
+    }
+
+    // ---- members + invitations -------------------------------------------
+
+    const members = ref<AccountMember[]>([])
+    const invitations = ref<AccountInvitation[]>([])
+
+    /** Load the active account's member roster + pending invitations. */
+    async function loadRoster(accountId: string) {
+      const [m, inv] = await Promise.all([
+        api.listAccountMembers(accountId),
+        api.listInvitations(accountId),
+      ])
+      members.value = m
+      invitations.value = inv
+    }
+
+    /** Invite a teammate by email; returns the accept link (for manual sharing). */
+    async function invite(accountId: string, email: string, roles: AccountRole[] = ['developer']) {
+      const { invitation, acceptUrl } = await api.createInvitation(accountId, { email, roles })
+      invitations.value = [invitation, ...invitations.value]
+      return acceptUrl
+    }
+
+    async function revokeInvite(accountId: string, invitationId: string) {
+      await api.revokeInvitation(accountId, invitationId)
+      invitations.value = invitations.value.filter((i) => i.id !== invitationId)
+    }
+
+    /** Set a member's role set (admin-only); patches the loaded roster in place. */
+    async function setMemberRoles(accountId: string, userId: string, roles: AccountRole[]) {
+      const updated = await api.setMemberRoles(accountId, userId, roles)
+      const i = members.value.findIndex((m) => m.userId === userId)
+      if (i >= 0) members.value[i] = updated
+      return updated
+    }
+
+    // ---- email sender connection -----------------------------------------
+
+    const emailConnection = ref<EmailConnection | null>(null)
+    const emailConfigured = ref(false)
+
+    async function loadEmailConnection(accountId: string) {
+      const res = await api.getEmailConnection(accountId)
+      emailConnection.value = res.connection
+      emailConfigured.value = res.configured
+    }
+
+    async function connectEmail(
+      accountId: string,
+      body: { provider: 'sendgrid' | 'resend'; apiKey: string; fromAddress: string },
+    ) {
+      emailConnection.value = await api.connectEmail(accountId, body)
+    }
+
+    async function disconnectEmail(accountId: string) {
+      await api.disconnectEmail(accountId)
+      emailConnection.value = null
+    }
+
+    return {
+      accounts,
+      activeAccountId,
+      activeAccount,
+      enabled,
+      ready,
+      members,
+      invitations,
+      emailConnection,
+      emailConfigured,
+      load,
+      createOrg,
+      switchTo,
+      setDefaultCloudProvider,
+      loadRoster,
+      invite,
+      revokeInvite,
+      setMemberRoles,
+      loadEmailConnection,
+      connectEmail,
+      disconnectEmail,
+    }
+  },
+  { persist: { pick: ['activeAccountId'] } },
+)

package/app/stores/agentConfig.ts

@@ -0,0 +1,35 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { AgentConfigDescriptor } from '~/types/domain'
+import { usePipelinesStore } from '~/stores/pipelines'
+
+/**
+ * The agent config-contribution catalog: the task-level parameters the registered
+ * agent kinds surface (e.g. the Tester's environment). Static metadata hydrated from
+ * the workspace snapshot. The task-creation form and inspector render the subset
+ * whose owning agent kind appears in the task's selected pipeline.
+ */
+export const useAgentConfigStore = defineStore('agentConfig', () => {
+  const descriptors = ref<AgentConfigDescriptor[]>([])
+
+  function hydrate(list: AgentConfigDescriptor[]) {
+    descriptors.value = [...list]
+  }
+
+  /** The descriptors contributed by the agent kinds of the given pipeline (by id). */
+  function forPipeline(pipelineId: string | undefined): AgentConfigDescriptor[] {
+    if (!pipelineId) return []
+    const pipeline = usePipelinesStore().getPipeline(pipelineId)
+    if (!pipeline) return []
+    const kinds = new Set<string>(pipeline.agentKinds)
+    return descriptors.value.filter((d) => kinds.has(d.agentKind))
+  }
+
+  /** The descriptors contributed across a set of agent kinds (by id). */
+  function forKinds(kinds: Iterable<string>): AgentConfigDescriptor[] {
+    const set = new Set(kinds)
+    return descriptors.value.filter((d) => set.has(d.agentKind))
+  }
+
+  return { descriptors, hydrate, forPipeline, forKinds }
+})

package/app/stores/agentRuns.ts

@@ -0,0 +1,122 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { AgentFailure, AgentRunKind, BootstrapJob, StepSubtasks } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useExecutionStore } from '~/stores/execution'
+
+/**
+ * A coarse, per-block view of the current "agent run" against a block, regardless
+ * of which flow produced it — enough for the board to render a failure banner +
+ * retry and a "working…" progress badge uniformly. The rich step-level UI still
+ * reads the full {@link ExecutionInstance} from the execution store.
+ */
+export interface AgentRunSummary {
+  blockId: string
+  kind: AgentRunKind
+  /** The run's own status: execution running|blocked|done|paused|failed,
+   * bootstrap pending|running|succeeded|failed. */
+  status: string
+  /** Id of the run, for the unified retry endpoint. */
+  runId: string
+  /** Structured failure when `status` is `failed`; null otherwise. */
+  failure: AgentFailure | null
+  /** Latest subtask counts for a live progress bar (null until reported). */
+  subtasks: StepSubtasks | null
+}
+
+/**
+ * Unified failure/retry surface over BOTH agent flows. Bootstrap runs are held
+ * here (they have no other home on the client); executions are read from the
+ * execution store so they're never duplicated. `byBlock` merges the two so a
+ * board card / inspector can look itself up and show the same failure banner +
+ * retry whether the block was made by a bootstrap or is running a task pipeline.
+ *
+ * This replaces the old bootstrap-only `bootstrap.byBlock`/`retry`, whose retry
+ * could silently vanish when the separate jobs projection failed to resolve.
+ */
+export const useAgentRunsStore = defineStore('agentRuns', () => {
+  const api = useApi()
+  const execution = useExecutionStore()
+
+  /** Bootstrap runs for this workspace, newest-first. */
+  const bootstrapJobs = ref<BootstrapJob[]>([])
+
+  /** Replace the cached bootstrap runs with a server snapshot. */
+  function hydrate(jobs: BootstrapJob[]) {
+    bootstrapJobs.value = [...jobs].sort((a, b) => b.createdAt - a.createdAt)
+  }
+
+  /**
+   * Patch a bootstrap run from a real-time `bootstrap` event (or after launching
+   * one): replace it in place by id, else prepend it. Keeps the service card
+   * reactive to live progress without a refetch.
+   */
+  function upsertBootstrap(job: BootstrapJob) {
+    const i = bootstrapJobs.value.findIndex((j) => j.id === job.id)
+    if (i >= 0) bootstrapJobs.value[i] = job
+    else bootstrapJobs.value.unshift(job)
+  }
+
+  /**
+   * The current run summary per block, merged from execution instances (task
+   * runs) and bootstrap runs (service frames). Executions take a block first;
+   * a frame block has no execution, so the newest bootstrap run wins there.
+   */
+  const byBlock = computed<Record<string, AgentRunSummary>>(() => {
+    const map: Record<string, AgentRunSummary> = {}
+    for (const e of execution.instances) {
+      map[e.blockId] = {
+        blockId: e.blockId,
+        kind: 'execution',
+        status: e.status,
+        runId: e.id,
+        failure: e.failure ?? null,
+        subtasks: e.steps[e.currentStep]?.subtasks ?? null,
+      }
+    }
+    // `bootstrapJobs` is newest-first; keep the first (newest) seen per block.
+    for (const job of bootstrapJobs.value) {
+      if (!job.blockId || map[job.blockId]) continue
+      map[job.blockId] = {
+        blockId: job.blockId,
+        kind: 'bootstrap',
+        status: job.status,
+        runId: job.id,
+        failure: job.failure,
+        subtasks: job.subtasks,
+      }
+    }
+    return map
+  })
+
+  /**
+   * Retry a failed run (bootstrap or execution) via the unified endpoint, then
+   * refresh the snapshot so both stores rehydrate — the card flips from failed
+   * back to "working…" as a fresh run is dispatched server-side.
+   */
+  async function retry(runId: string) {
+    const ws = useWorkspaceStore()
+    const personal = usePersonalSubscriptionsStore()
+    // A failed run on a Claude-pinned block needs the retrying user's personal password;
+    // supplied from cache and prompted (then retried) on a 428, exactly like start.
+    await personal.withCredential(async (password) => {
+      await api.retryAgentRun(ws.requireId(), runId, password)
+      await ws.refresh()
+    })
+  }
+
+  /**
+   * Explicitly stop a running run (bootstrap or execution) via the unified endpoint:
+   * the backend kills the per-run container + tears down the durable driver, then
+   * marks the run cancelled. Refresh so both stores rehydrate and the card flips out
+   * of its "running" state. Returns the resolved kind so the caller can word a toast.
+   */
+  async function stop(runId: string): Promise<AgentRunKind> {
+    const ws = useWorkspaceStore()
+    const { kind } = await api.stopAgentRun(ws.requireId(), runId)
+    await ws.refresh()
+    return kind
+  }
+
+  return { bootstrapJobs, hydrate, upsertBootstrap, byBlock, retry, stop }
+})

package/app/stores/agents.ts

@@ -0,0 +1,40 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import { AGENT_ARCHETYPES, AGENT_BY_KIND, uid } from '~/utils/catalog'
+import type { AgentArchetype, AgentKind } from '~/types/domain'
+
+/**
+ * The agent palette. Seeded from the static catalog, but custom agents can be
+ * added at runtime (they show up in the pipeline builder). Newly created agents
+ * are also registered into AGENT_BY_KIND so the many components that look an
+ * agent up by kind keep rendering it correctly.
+ */
+export const useAgentsStore = defineStore('agents', () => {
+  const archetypes = ref<AgentArchetype[]>([...AGENT_ARCHETYPES])
+
+  function get(kind: AgentKind) {
+    return AGENT_BY_KIND[kind]
+  }
+
+  function addAgent(input: {
+    label: string
+    description?: string
+    icon?: string
+    color?: string
+  }): AgentArchetype {
+    const archetype: AgentArchetype = {
+      // custom kinds are free-form ids; cast keeps the existing AgentKind typing happy
+      kind: uid('agent') as AgentKind,
+      label: input.label.trim() || 'Custom Agent',
+      description: input.description?.trim() || 'Custom agent.',
+      icon: input.icon || 'i-lucide-sparkles',
+      color: input.color || '#22d3ee',
+    }
+    // register for kind-based lookups across the app, then surface in the palette
+    AGENT_BY_KIND[archetype.kind] = archetype
+    archetypes.value.push(archetype)
+    return archetype
+  }
+
+  return { archetypes, get, addAgent }
+})

package/app/stores/apiKeys.ts

@@ -0,0 +1,108 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { AddApiKeyInput, ApiKey, ApiKeyProvider } from '~/types/domain'
+
+/**
+ * The direct-provider API keys reachable from a workspace: the workspace's own keys
+ * plus the signed-in user's personal keys. Account-scoped keys (shared by every
+ * workspace in the account, admin-managed) are loaded separately via `loadAccountKeys`
+ * and surfaced in account/team settings. Onboarded via UI, stored encrypted + pooled by
+ * the backend; keys are write-only so only metadata + rolling-window usage is ever
+ * returned. `configuredProviders` drives the model picker (a direct model is selectable
+ * once a key for its provider is connected at any reachable scope).
+ */
+export const useApiKeysStore = defineStore('apiKeys', () => {
+  const api = useApi()
+  const workspaceKeys = ref<ApiKey[]>([])
+  const userKeys = ref<ApiKey[]>([])
+  const accountKeys = ref<ApiKey[]>([])
+  const accountId = ref<string | null>(null)
+  const workspaceId = ref<string | null>(null)
+  const loading = ref(false)
+
+  async function load(ws: string) {
+    workspaceId.value = ws
+    loading.value = true
+    try {
+      const [wsRes, meRes] = await Promise.all([
+        api.listWorkspaceApiKeys(ws),
+        api.listMyApiKeys().catch(() => ({ keys: [] as ApiKey[] })),
+      ])
+      workspaceKeys.value = wsRes.keys
+      userKeys.value = meRes.keys
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function addWorkspaceKey(input: AddApiKeyInput) {
+    if (!workspaceId.value) return
+    const created = await api.addWorkspaceApiKey(workspaceId.value, input)
+    workspaceKeys.value = [...workspaceKeys.value, created]
+  }
+
+  async function removeWorkspaceKey(id: string) {
+    if (!workspaceId.value) return
+    await api.removeWorkspaceApiKey(workspaceId.value, id)
+    workspaceKeys.value = workspaceKeys.value.filter((k) => k.id !== id)
+  }
+
+  async function addUserKey(input: AddApiKeyInput) {
+    const created = await api.addMyApiKey(input)
+    userKeys.value = [...userKeys.value, created]
+  }
+
+  async function removeUserKey(id: string) {
+    await api.removeMyApiKey(id)
+    userKeys.value = userKeys.value.filter((k) => k.id !== id)
+  }
+
+  // ---- Account-scoped keys (admin-managed, shared by the account's workspaces) ----
+
+  async function loadAccountKeys(acc: string) {
+    accountId.value = acc
+    accountKeys.value = (await api.listAccountApiKeys(acc)).keys
+  }
+
+  async function addAccountKey(input: AddApiKeyInput) {
+    if (!accountId.value) return
+    const created = await api.addAccountApiKey(accountId.value, input)
+    accountKeys.value = [...accountKeys.value, created]
+  }
+
+  async function removeAccountKey(id: string) {
+    if (!accountId.value) return
+    await api.removeAccountApiKey(accountId.value, id)
+    accountKeys.value = accountKeys.value.filter((k) => k.id !== id)
+  }
+
+  /** Every key reachable from the workspace (workspace + user scopes), newest first. */
+  const allKeys = computed<ApiKey[]>(() => [...workspaceKeys.value, ...userKeys.value])
+
+  /** Providers with at least one reachable connected key. */
+  const configuredProviders = computed(
+    () => new Set<ApiKeyProvider>(allKeys.value.map((k) => k.provider)),
+  )
+
+  function hasProvider(provider: ApiKeyProvider | undefined): boolean {
+    return provider ? configuredProviders.value.has(provider) : false
+  }
+
+  return {
+    workspaceKeys,
+    userKeys,
+    accountKeys,
+    allKeys,
+    loading,
+    load,
+    addWorkspaceKey,
+    removeWorkspaceKey,
+    addUserKey,
+    removeUserKey,
+    loadAccountKeys,
+    addAccountKey,
+    removeAccountKey,
+    configuredProviders,
+    hasProvider,
+  }
+})

package/app/stores/auth.ts

@@ -0,0 +1,166 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { AuthUser } from '~/types/domain'
+
+/**
+ * "Login with GitHub" session state. The backend mints a signed session token
+ * and hands it back via a URL fragment after the OAuth round-trip; we persist
+ * just that token and replay it as a bearer header on every API call (see
+ * `useApi`). Auth is opt-in on the backend, so `required` gates whether the UI
+ * shows a login screen at all — when the backend has auth disabled the app runs
+ * exactly as before.
+ */
+export const useAuthStore = defineStore(
+  'auth',
+  () => {
+    const api = useApi()
+    const apiBase = useRuntimeConfig().public.apiBase
+
+    /** Signed session token (persisted), or null when signed out. */
+    const token = ref<string | null>(null)
+    /** The signed-in user, resolved from the token on boot. */
+    const user = ref<AuthUser | null>(null)
+    /** Whether the backend requires authentication. */
+    const required = ref(false)
+    /** Which login providers the backend offers (drives the login UI). */
+    const providers = ref({ github: false, password: false, google: false })
+    /**
+     * Local-mode signals from the backend. Present only when running the local facade;
+     * `githubPatSetupUrl` is set when local mode has no GitHub PAT configured (drives the
+     * setup banner). Null on every other facade.
+     */
+    const localMode = ref<{ enabled: boolean; githubPatSetupUrl?: string } | null>(null)
+    /** True once the initial auth handshake has settled. */
+    const ready = ref(false)
+
+    /** May the app render? True when auth is off, or on with a known user. */
+    const isAuthenticated = computed(() => !required.value || user.value !== null)
+
+    /** Pull a token handed back in the post-login URL fragment (#token=…). */
+    function consumeRedirectToken() {
+      if (typeof window === 'undefined') return
+      const match = /(?:^#|[#&])token=([^&]+)/.exec(window.location.hash)
+      if (!match) return
+      token.value = decodeURIComponent(match[1]!)
+      // Strip the token from the URL so it isn't left in history or shared.
+      history.replaceState(null, '', window.location.pathname + window.location.search)
+    }
+
+    /** Resolve auth state: capture any redirect token, then check the backend. */
+    async function bootstrap() {
+      consumeRedirectToken()
+      try {
+        const config = await api.getAuthConfig()
+        required.value = config.enabled
+        if (config.providers) providers.value = config.providers
+        localMode.value = config.localMode ?? null
+      } catch {
+        // Backend unreachable — let the board's own error UI handle it.
+        required.value = false
+        ready.value = true
+        return
+      }
+
+      if (required.value && token.value) {
+        try {
+          user.value = (await api.getMe()).user
+        } catch {
+          user.value = null
+        }
+        if (!user.value) token.value = null
+      }
+      // An already-signed-in user who followed an invite link redeems it here (a
+      // brand-new user redeems it server-side during signup/OAuth instead).
+      if (user.value) await maybeAcceptInvite()
+      ready.value = true
+    }
+
+    /** Redeem an `?invite=` token in the URL for the signed-in user, then clean the URL. */
+    async function maybeAcceptInvite() {
+      if (typeof window === 'undefined') return
+      const params = new URLSearchParams(window.location.search)
+      const inviteToken = params.get('invite')
+      if (!inviteToken) return
+      try {
+        await api.acceptInvite(inviteToken)
+      } catch {
+        // Stale/already-accepted invite — ignore and let the app load normally.
+      }
+      params.delete('invite')
+      const qs = params.toString()
+      history.replaceState(null, '', window.location.pathname + (qs ? `?${qs}` : ''))
+    }
+
+    /** Build a post-login redirect back to the current page, with an optional invite. */
+    function redirectTarget(invite?: string): string {
+      const here = window.location.origin + window.location.pathname
+      const params = new URLSearchParams({ redirect: here })
+      if (invite) params.set('invite', invite)
+      return params.toString()
+    }
+
+    /** Send the browser to the backend's GitHub login, returning here after. */
+    function login(invite?: string) {
+      if (typeof window === 'undefined') return
+      window.location.href = `${apiBase}/auth/login?${redirectTarget(invite)}`
+    }
+
+    /** Send the browser to the backend's Google login, returning here after. */
+    function loginWithGoogle(invite?: string) {
+      if (typeof window === 'undefined') return
+      window.location.href = `${apiBase}/auth/google/login?${redirectTarget(invite)}`
+    }
+
+    /** Apply a freshly-minted token + user (from password signup/login). */
+    function applySession(result: { token: string; user: AuthUser }) {
+      token.value = result.token
+      user.value = result.user
+    }
+
+    /** Register a new email/password user (optionally redeeming an invite). */
+    async function signup(body: {
+      email: string
+      password: string
+      name?: string
+      invite?: string
+    }) {
+      applySession(await api.signup(body))
+    }
+
+    /** Sign in with email/password. */
+    async function passwordLogin(body: { email: string; password: string }) {
+      applySession(await api.passwordLogin(body))
+    }
+
+    /** Drop the local session (sessions are stateless server-side). */
+    function logout() {
+      api.logout().catch(() => {})
+      token.value = null
+      user.value = null
+    }
+
+    /** Called by the API client when a request comes back 401. */
+    function handleUnauthorized() {
+      token.value = null
+      user.value = null
+    }
+
+    return {
+      token,
+      user,
+      required,
+      providers,
+      localMode,
+      ready,
+      isAuthenticated,
+      bootstrap,
+      login,
+      loginWithGoogle,
+      signup,
+      passwordLogin,
+      logout,
+      handleUnauthorized,
+    }
+  },
+  { persist: { pick: ['token'] } },
+)