feat(workspace): workspace domain — schema, store, routes, daemon linking

apps/dashboard/src/components/AuthGate.tsx

@@ -4,8 +4,6 @@ import { Alert, AlertDescription } from '@/components/ui/alert';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 
-import { setSessionMode } from '../api/client.js';
-
 type AuthMode = 'loading' | 'authenticated' | 'create-account' | 'login';
 
 interface SetupStatus {
@@ -28,7 +26,6 @@ export function AuthGate({ children }: { children: React.ReactNode }) {
   async function checkAuth() {
     // Check setup status
     // Check OIDC session first (before setup status, to avoid redirect loops)
-    let isOidcAuthenticated = false;
     try {
       const meRes = await fetch('/auth/me', { credentials: 'include' });
       if (meRes.ok) {

packages/domains/daemon/src/store.ts

@@ -10,6 +10,7 @@ export interface StoredDaemon {
   status: DaemonStatus;
   snapshot: string;
   trigger: Trigger;
+  workspace?: string | undefined;
   workload?: Workload | undefined;
   agent?: AgentConfig | undefined;
   resources?: Resources | undefined;
@@ -46,6 +47,7 @@ export function createDaemonStore(): DaemonStore {
         status: 'active',
         snapshot: request.snapshot,
         trigger: request.trigger,
+        workspace: request.workspace,
         workload: request.workload,
         agent: request.agent,
         resources: request.resources,

packages/domains/daemon/src/types.ts

@@ -87,6 +87,8 @@ export const CreateDaemonRequestSchema = z
     description: z.string().default(''),
     snapshot: NonEmptyStringSchema,
     trigger: TriggerSchema,
+    /** Workspace this daemon belongs to */
+    workspace: z.string().optional(),
     /** Workload script — required unless agent is configured */
     workload: WorkloadSchema.optional(),
     /** Agent framework config — auto-generates the workload script */
@@ -120,6 +122,7 @@ export const DaemonListItemSchema = z.object({
   status: DaemonStatus,
   trigger: TriggerSchema,
   stats: DaemonStatsSchema,
+  workspace: z.string().optional(),
 });
 
 export type DaemonListItem = z.infer<typeof DaemonListItemSchema>;

packages/domains/workspace/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@paws/domain-workspace",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Workspace domain — Workspace, WorkspaceStore, routes",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "catalog:",
+    "@paws/domain-common": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "vitest": "catalog:"
+  }
+}

packages/domains/workspace/src/index.ts

@@ -0,0 +1,27 @@
+export {
+  CreateWorkspaceRequestSchema,
+  UpdateWorkspaceRequestSchema,
+  WorkspaceListResponseSchema,
+  WorkspaceRepoSchema,
+  WorkspaceSchema,
+  WorkspaceSettingsSchema,
+} from './types.js';
+export type {
+  CreateWorkspaceRequest,
+  UpdateWorkspaceRequest,
+  Workspace,
+  WorkspaceListResponse,
+  WorkspaceRepo,
+  WorkspaceSettings,
+} from './types.js';
+
+export { createWorkspaceStore } from './store.js';
+export type { WorkspaceStore } from './store.js';
+
+export {
+  createWorkspaceRoute,
+  deleteWorkspaceRoute,
+  getWorkspaceRoute,
+  listWorkspacesRoute,
+  updateWorkspaceRoute,
+} from './routes.js';

packages/domains/workspace/src/routes.ts

@@ -0,0 +1,120 @@
+import { createRoute, z } from '@hono/zod-openapi';
+import { ErrorResponseSchema } from '@paws/domain-common';
+import {
+  CreateWorkspaceRequestSchema,
+  UpdateWorkspaceRequestSchema,
+  WorkspaceListResponseSchema,
+  WorkspaceSchema,
+} from './types.js';
+
+export const createWorkspaceRoute = createRoute({
+  method: 'post',
+  path: '/v1/workspaces',
+  tags: ['Workspaces'],
+  request: {
+    body: {
+      content: {
+        'application/json': {
+          schema: CreateWorkspaceRequestSchema,
+        },
+      },
+    },
+  },
+  responses: {
+    201: {
+      description: 'Workspace created',
+      content: { 'application/json': { schema: WorkspaceSchema } },
+    },
+    400: {
+      description: 'Validation error',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+    409: {
+      description: 'Workspace name already exists',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+});
+
+export const listWorkspacesRoute = createRoute({
+  method: 'get',
+  path: '/v1/workspaces',
+  tags: ['Workspaces'],
+  responses: {
+    200: {
+      description: 'List of workspaces',
+      content: { 'application/json': { schema: WorkspaceListResponseSchema } },
+    },
+  },
+});
+
+export const getWorkspaceRoute = createRoute({
+  method: 'get',
+  path: '/v1/workspaces/{id}',
+  tags: ['Workspaces'],
+  request: {
+    params: z.object({ id: z.string().min(1) }),
+  },
+  responses: {
+    200: {
+      description: 'Workspace detail',
+      content: { 'application/json': { schema: WorkspaceSchema } },
+    },
+    404: {
+      description: 'Workspace not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+});
+
+export const updateWorkspaceRoute = createRoute({
+  method: 'put',
+  path: '/v1/workspaces/{id}',
+  tags: ['Workspaces'],
+  request: {
+    params: z.object({ id: z.string().min(1) }),
+    body: {
+      content: {
+        'application/json': {
+          schema: UpdateWorkspaceRequestSchema,
+        },
+      },
+    },
+  },
+  responses: {
+    200: {
+      description: 'Workspace updated',
+      content: { 'application/json': { schema: WorkspaceSchema } },
+    },
+    404: {
+      description: 'Workspace not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+});
+
+export const deleteWorkspaceRoute = createRoute({
+  method: 'delete',
+  path: '/v1/workspaces/{id}',
+  tags: ['Workspaces'],
+  request: {
+    params: z.object({ id: z.string().min(1) }),
+  },
+  responses: {
+    200: {
+      description: 'Workspace deleted',
+      content: {
+        'application/json': {
+          schema: z.object({
+            id: z.string(),
+            deleted: z.literal(true),
+          }),
+        },
+      },
+    },
+    404: {
+      description: 'Workspace not found',
+      content: { 'application/json': { schema: ErrorResponseSchema } },
+    },
+  },
+});

packages/domains/workspace/src/store.ts

@@ -0,0 +1,57 @@
+import type { CreateWorkspaceRequest, Workspace } from './types.js';
+
+export interface WorkspaceStore {
+  create(workspace: Workspace): Workspace;
+  get(id: string): Workspace | undefined;
+  getByName(name: string): Workspace | undefined;
+  list(): Workspace[];
+  update(id: string, partial: Partial<CreateWorkspaceRequest>): Workspace | undefined;
+  delete(id: string): boolean;
+}
+
+/** In-memory workspace store */
+export function createWorkspaceStore(): WorkspaceStore {
+  const workspaces = new Map<string, Workspace>();
+
+  return {
+    create(workspace) {
+      workspaces.set(workspace.id, workspace);
+      return workspace;
+    },
+
+    get(id) {
+      return workspaces.get(id);
+    },
+
+    getByName(name) {
+      for (const workspace of workspaces.values()) {
+        if (workspace.name === name) return workspace;
+      }
+      return undefined;
+    },
+
+    list() {
+      return [...workspaces.values()];
+    },
+
+    update(id, partial) {
+      const workspace = workspaces.get(id);
+      if (!workspace) return undefined;
+      const updated: Workspace = {
+        ...workspace,
+        ...(partial.name !== undefined && { name: partial.name }),
+        ...(partial.description !== undefined && { description: partial.description }),
+        ...(partial.type !== undefined && { type: partial.type }),
+        ...(partial.repos !== undefined && { repos: partial.repos }),
+        ...(partial.settings !== undefined && { settings: partial.settings }),
+        updatedAt: new Date().toISOString(),
+      };
+      workspaces.set(id, updated);
+      return updated;
+    },
+
+    delete(id) {
+      return workspaces.delete(id);
+    },
+  };
+}