@usebruno/filestore 0.9.0 → 0.11.0

package/src/formats/yml/common/datatype.spec.ts

@@ -0,0 +1,110 @@
+import {
+  isBrunoVariableDataType,
+  isTypedValue,
+  hasTypedMetadata,
+  toOpenCollectionTypedValue,
+  fromOpenCollectionTypedValue
+} from './datatype';
+
+describe('dataType helpers', () => {
+  describe('isBrunoVariableDataType', () => {
+    it('returns true for supported Bruno datatypes', () => {
+      expect(isBrunoVariableDataType('string')).toBe(true);
+      expect(isBrunoVariableDataType('number')).toBe(true);
+      expect(isBrunoVariableDataType('boolean')).toBe(true);
+      expect(isBrunoVariableDataType('object')).toBe(true);
+    });
+
+    it('returns false for unsupported OpenCollection datatypes (e.g. null)', () => {
+      expect(isBrunoVariableDataType('null')).toBe(false);
+    });
+
+    it('returns false for non-string inputs', () => {
+      expect(isBrunoVariableDataType(undefined)).toBe(false);
+      expect(isBrunoVariableDataType(null)).toBe(false);
+      expect(isBrunoVariableDataType(42)).toBe(false);
+      expect(isBrunoVariableDataType({})).toBe(false);
+    });
+  });
+
+  describe('isTypedValue', () => {
+    it('returns true for OpenCollection typed-value shapes', () => {
+      expect(isTypedValue({ type: 'number', data: '42' })).toBe(true);
+      expect(isTypedValue({ type: 'object', data: '{}' })).toBe(true);
+    });
+
+    it('returns false for plain strings', () => {
+      expect(isTypedValue('hello')).toBe(false);
+      expect(isTypedValue('')).toBe(false);
+    });
+
+    it('returns false for arrays, null, and objects missing type/data', () => {
+      expect(isTypedValue(null)).toBe(false);
+      expect(isTypedValue([])).toBe(false);
+      expect(isTypedValue([{ type: 'number', data: '1' }])).toBe(false);
+      expect(isTypedValue({ type: 'number' })).toBe(false);
+      expect(isTypedValue({ data: '1' })).toBe(false);
+      expect(isTypedValue({})).toBe(false);
+    });
+  });
+
+  describe('hasTypedMetadata', () => {
+    it('returns false when dataType is missing', () => {
+      expect(hasTypedMetadata({})).toBe(false);
+    });
+
+    it('returns false when dataType is the string default', () => {
+      expect(hasTypedMetadata({ dataType: 'string' })).toBe(false);
+    });
+
+    it('returns true for non-string datatypes', () => {
+      expect(hasTypedMetadata({ dataType: 'number' })).toBe(true);
+      expect(hasTypedMetadata({ dataType: 'boolean' })).toBe(true);
+      expect(hasTypedMetadata({ dataType: 'object' })).toBe(true);
+    });
+  });
+
+  describe('toOpenCollectionTypedValue', () => {
+    it('builds a {type, data} struct from dataType + stringified value', () => {
+      expect(toOpenCollectionTypedValue({ dataType: 'number' }, '42'))
+        .toEqual({ type: 'number', data: '42' });
+      expect(toOpenCollectionTypedValue({ dataType: 'boolean' }, 'true'))
+        .toEqual({ type: 'boolean', data: 'true' });
+      expect(toOpenCollectionTypedValue({ dataType: 'object' }, '{"a":1}'))
+        .toEqual({ type: 'object', data: '{"a":1}' });
+    });
+
+    it('falls back to type "string" when dataType is missing', () => {
+      expect(toOpenCollectionTypedValue({}, 'hello'))
+        .toEqual({ type: 'string', data: 'hello' });
+    });
+  });
+
+  describe('fromOpenCollectionTypedValue', () => {
+    it('coerces typed values to their declared dataType', () => {
+      expect(fromOpenCollectionTypedValue({ type: 'number', data: '42' }))
+        .toEqual({ value: 42, dataType: 'number' });
+      expect(fromOpenCollectionTypedValue({ type: 'boolean', data: 'true' }))
+        .toEqual({ value: true, dataType: 'boolean' });
+      expect(fromOpenCollectionTypedValue({ type: 'object', data: '{"a":1}' }))
+        .toEqual({ value: { a: 1 }, dataType: 'object' });
+    });
+
+    it('falls back to string when the declared type is unsupported (e.g. null)', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'null' as any, data: '' });
+      expect(result.dataType).toBeUndefined();
+    });
+
+    it('coerces non-string data to a string before coercing by dataType', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'number', data: 42 as any });
+      expect(result.value).toBe(42);
+      expect(result.dataType).toBe('number');
+    });
+
+    it('returns the raw string when coercion fails (e.g. non-numeric @number)', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'number', data: 'not-a-number' });
+      expect(result.value).toBe('not-a-number');
+      expect(result.dataType).toBe('number');
+    });
+  });
+});

package/src/formats/yml/common/datatype.ts

@@ -0,0 +1,57 @@
+import type { VariableTypedValue } from '@opencollection/types/common/variables';
+import {
+  parseValueByDataType,
+  BrunoVariableDataType,
+  isBrunoVariableDataType,
+  valueToString
+} from '@usebruno/common/utils';
+
+export { BrunoVariableDataType, isBrunoVariableDataType };
+
+export const serializeVariableValue = (value: unknown): string => {
+  if (value !== null && typeof value === 'object') {
+    return JSON.stringify(value, null, 2);
+  }
+  return valueToString(value);
+};
+
+export const isTypedValue = (value: unknown): value is VariableTypedValue => {
+  return typeof value === 'object'
+    && value !== null
+    && !Array.isArray(value)
+    && 'type' in value
+    && 'data' in value;
+};
+
+export interface TypedVariableFields {
+  dataType?: BrunoVariableDataType;
+}
+
+export const hasTypedMetadata = (v: TypedVariableFields): boolean => {
+  return !!v.dataType && v.dataType !== 'string';
+};
+
+export const toOpenCollectionTypedValue = (
+  v: TypedVariableFields,
+  dataStr: string
+): VariableTypedValue => {
+  return {
+    type: (v.dataType || 'string') as VariableTypedValue['type'],
+    data: dataStr
+  };
+};
+
+// `'string'` is the implicit default — omitted from the result.
+export const fromOpenCollectionTypedValue = (
+  typed: VariableTypedValue
+): { value: any } & TypedVariableFields => {
+  const dataStr = typeof typed.data === 'string' ? typed.data : String(typed.data ?? '');
+  const dataType: BrunoVariableDataType = isBrunoVariableDataType(typed.type) ? typed.type : 'string';
+  const result: { value: any } & TypedVariableFields = {
+    value: parseValueByDataType(dataStr, dataType)
+  };
+  if (dataType !== 'string') {
+    result.dataType = dataType;
+  }
+  return result;
+};

package/src/formats/yml/common/headers.ts

@@ -51,6 +51,10 @@ export const toBrunoHttpHeaders = (headers: HttpRequestHeader[] | HttpResponseHe
       enabled: ('disabled' in header) ? header.disabled !== true : true
     };
 
+    if ('description' in header && header.description) {
+      brunoHeader.description = typeof header.description === 'string' ? header.description : (header.description as any)?.content || '';
+    }
+
     return brunoHeader;
   });
 

package/src/formats/yml/common/variables.spec.ts

@@ -0,0 +1,127 @@
+import { toOpenCollectionVariables, toBrunoVariables } from './variables';
+
+describe('toOpenCollectionVariables', () => {
+  it('returns undefined for null / empty input', () => {
+    expect(toOpenCollectionVariables(null)).toBeUndefined();
+    expect(toOpenCollectionVariables(undefined)).toBeUndefined();
+    expect(toOpenCollectionVariables([])).toBeUndefined();
+    expect(toOpenCollectionVariables({ req: [], res: [] })).toBeUndefined();
+  });
+
+  it('serializes plain string variables as a raw string value', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: true } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('serializes typed variables as a {type, data} struct', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'port', value: 3000, enabled: true, dataType: 'number' } as any,
+      { uid: 'u2', name: 'flag', value: true, enabled: true, dataType: 'boolean' } as any,
+      { uid: 'u3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'port', value: { type: 'number', data: '3000' } },
+      { name: 'flag', value: { type: 'boolean', data: 'true' } },
+      { name: 'config', value: { type: 'object', data: '{\n  "a": 1\n}' } }
+    ]);
+  });
+
+  it('does not emit a typed struct for the string default dataType', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: true, dataType: 'string' } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('marks disabled variables and preserves description', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: false, description: 'auth key' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'apiKey', value: 'abc', description: 'auth key', disabled: true }
+    ]);
+  });
+
+  it('accepts the folder { req, res } shape and only emits req vars', () => {
+    const out = toOpenCollectionVariables({
+      req: [{ uid: 'u1', name: 'a', value: '1', enabled: true } as any],
+      res: [{ uid: 'u2', name: 'b', value: '2', enabled: true } as any]
+    });
+
+    expect(out).toEqual([{ name: 'a', value: '1' }]);
+  });
+});
+
+describe('toBrunoVariables', () => {
+  it('returns empty req/res for null / empty input', () => {
+    expect(toBrunoVariables(null)).toEqual({ req: [], res: [] });
+    expect(toBrunoVariables(undefined)).toEqual({ req: [], res: [] });
+    expect(toBrunoVariables([])).toEqual({ req: [], res: [] });
+  });
+
+  it('parses plain string variables into Bruno req vars', () => {
+    const { req } = toBrunoVariables([
+      { name: 'apiKey', value: 'abc' } as any
+    ]);
+
+    expect(req).toHaveLength(1);
+    const v = req![0];
+    expect(v).toMatchObject({
+      name: 'apiKey',
+      value: 'abc',
+      enabled: true,
+      local: false
+    });
+    expect(v.uid).toEqual(expect.any(String));
+    expect(v.dataType).toBeUndefined();
+  });
+
+  it('parses typed-value variables into typed Bruno variables', () => {
+    const { req } = toBrunoVariables([
+      { name: 'port', value: { type: 'number', data: '3000' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'true' } } as any,
+      { name: 'config', value: { type: 'object', data: '{"a":1}' } } as any
+    ]);
+
+    expect(req![0]).toMatchObject({ name: 'port', value: 3000, dataType: 'number' });
+    expect(req![1]).toMatchObject({ name: 'flag', value: true, dataType: 'boolean' });
+    expect(req![2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object' });
+  });
+
+  it('falls back to the raw string when typed data fails to coerce', () => {
+    const { req } = toBrunoVariables([
+      { name: 'port', value: { type: 'number', data: 'not-a-number' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'not-a-boolean' } } as any,
+      { name: 'config', value: { type: 'object', data: 'not-a-object' } } as any
+    ]);
+
+    expect(req![0]).toMatchObject({ name: 'port', value: 'not-a-number', dataType: 'number' });
+    expect(typeof req![0].value).toBe('string');
+    expect(req![1]).toMatchObject({ name: 'flag', value: 'not-a-boolean', dataType: 'boolean' });
+    expect(typeof req![1].value).toBe('string');
+    expect(req![2]).toMatchObject({ name: 'config', value: 'not-a-object', dataType: 'object' });
+    expect(typeof req![2].value).toBe('string');
+  });
+
+  it('respects the disabled flag', () => {
+    const { req } = toBrunoVariables([
+      { name: 'a', value: '1', disabled: true } as any
+    ]);
+
+    expect(req![0].enabled).toBe(false);
+  });
+
+  it('extracts description.content when description is a structured object', () => {
+    const { req } = toBrunoVariables([
+      { name: 'a', value: '1', description: { content: 'note' } } as any
+    ]);
+
+    expect(req![0].description).toBe('note');
+  });
+});

package/src/formats/yml/common/variables.ts

@@ -1,7 +1,14 @@
-import { Variable } from '@opencollection/types/common/variables';
+import { Variable, VariableTypedValue } from '@opencollection/types/common/variables';
 import { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
 import { Variable as BrunoVariable, Variables as BrunoVariables } from '@usebruno/schema-types/common/variables';
 import { uuid, ensureString } from '../../../utils';
+import {
+  isTypedValue,
+  hasTypedMetadata,
+  toOpenCollectionTypedValue,
+  fromOpenCollectionTypedValue,
+  serializeVariableValue
+} from './datatype';
 
 /**
  * Convert Bruno pre-request variables to OpenCollection variables format.
@@ -19,9 +26,10 @@ export const toOpenCollectionVariables = (variables: BrunoFolderRequest['vars']
   }
 
   const ocVariables: Variable[] = reqVarsArray.map((v: BrunoVariable): Variable => {
+    const valueStr = serializeVariableValue(v.value);
     const variable: Variable = {
       name: v.name || '',
-      value: v.value || ''
+      value: hasTypedMetadata(v) ? toOpenCollectionTypedValue(v, valueStr) : valueStr
     };
 
     if (v?.description?.trim().length) {
@@ -49,19 +57,25 @@ export const toBrunoVariables = (variables: Variable[] | null | undefined): { re
   const reqVars: BrunoVariables = [];
 
   variables.forEach((v: Variable) => {
-    const variable: BrunoVariable = {
+    const base: BrunoVariable = {
       uid: uuid(),
       name: ensureString(v.name),
-      value: ensureString(v.value),
+      value: '',
       enabled: v.disabled !== true,
       local: false
     };
 
+    if (isTypedValue(v.value)) {
+      Object.assign(base, fromOpenCollectionTypedValue(v.value));
+    } else {
+      base.value = ensureString(v.value);
+    }
+
     if (v.description) {
-      variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+      base.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
     }
 
-    reqVars.push(variable);
+    reqVars.push(base);
   });
 
   return { req: reqVars, res: [] };

package/src/formats/yml/items/parseApp.ts

@@ -0,0 +1,37 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import { uuid } from '../../../utils';
+
+export interface AppFile {
+  info: {
+    name?: string;
+    type: 'app';
+    seq?: number;
+    tags?: string[];
+  };
+  code?: string;
+}
+
+const parseApp = (ocApp: AppFile): BrunoItem => {
+  const info = ocApp.info || ({} as AppFile['info']);
+
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'app',
+    seq: typeof info.seq === 'number' ? info.seq : 1,
+    name: info.name || 'App',
+    tags: Array.isArray(info.tags) ? info.tags : [],
+    request: null,
+    settings: null,
+    app: { code: ocApp.code || '' },
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  return brunoItem;
+};
+
+export default parseApp;

package/src/formats/yml/items/parseGraphQLRequest.ts

@@ -98,6 +98,14 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   // settings
   if (ocRequest.settings) {
     const settings: BrunoHttpItemSettings = {};

package/src/formats/yml/items/parseGrpcRequest.ts

@@ -1,6 +1,6 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
-import type { GrpcRequest, GrpcMetadata } from '@opencollection/types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata, GrpcMessageVariant } from '@opencollection/types/requests/grpc';
 import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
 import { toBrunoAuth } from '../common/auth';
 import { toBrunoVariables } from '../common/variables';
@@ -21,6 +21,13 @@ const toBrunoGrpcMetadata = (metadata: GrpcMetadata[] | null | undefined): Bruno
       enabled: meta.disabled !== true
     };
 
+    if (meta.description) {
+      const desc = typeof meta.description === 'string' ? meta.description : (meta.description as any)?.content || '';
+      if (desc.trim().length) {
+        brunoMeta.description = desc;
+      }
+    }
+
     return brunoMeta;
   });
 
@@ -57,10 +64,16 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
   };
 
   // message
-  if (isNonEmptyString(grpc?.message)) {
+  const rawMessage = grpc?.message;
+  if (Array.isArray(rawMessage)) {
+    brunoRequest.body.grpc = (rawMessage as GrpcMessageVariant[]).map(({ title, message }, index) => ({
+      name: title || `message ${index + 1}`,
+      content: ensureString(message)
+    }));
+  } else if (isNonEmptyString(rawMessage)) {
     brunoRequest.body.grpc = [{
       name: '',
-      content: grpc?.message as string
+      content: rawMessage as string
     }];
   }
 
@@ -110,6 +123,14 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   return brunoItem;
 };
 

package/src/formats/yml/items/parseHttpRequest.ts

@@ -9,6 +9,7 @@ import { toBrunoVariables } from '../common/variables';
 import { toBrunoPostResponseVariables } from '../common/actions';
 import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
+import { toBrunoApp } from '../common/app';
 import { uuid, ensureString } from '../../../utils';
 
 const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
@@ -79,6 +80,9 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     brunoRequest.docs = ocRequest.docs;
   }
 
+  // app
+  const app = toBrunoApp((ocRequest as any).app);
+
   // bruno item
   const brunoItem: BrunoItem = {
     uid: uuid(),
@@ -88,6 +92,7 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     tags: info?.tags || [],
     request: brunoRequest,
     settings: null,
+    app,
     fileContent: null,
     root: null,
     items: [],
@@ -96,6 +101,14 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   // settings
   if (ocRequest.settings) {
     const settings: BrunoHttpItemSettings = {};

package/src/formats/yml/items/parseWebsocketRequest.ts

@@ -1,6 +1,6 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
-import type { WebSocketRequest, WebSocketMessage } from '@opencollection/types/requests/websocket';
+import type { WebSocketRequest, WebSocketMessage, WebSocketMessageVariant } from '@opencollection/types/requests/websocket';
 import { toBrunoAuth } from '../common/auth';
 import { toBrunoHttpHeaders } from '../common/headers';
 import { toBrunoVariables } from '../common/variables';
@@ -35,14 +35,26 @@ const parseWebsocketRequest = (ocRequest: WebSocketRequest): BrunoItem => {
 
   // message
   if (websocket?.message) {
-    const message = websocket.message as WebSocketMessage;
-    const messageData = ensureString(message.data);
-    if (messageData.trim().length) {
-      brunoRequest.body.ws = [{
-        name: '',
-        type: message.type || 'text',
-        content: messageData
-      }];
+    if (Array.isArray(websocket.message)) {
+      // multiple messages: WebSocketMessageVariant[]
+      const variants = websocket.message as WebSocketMessageVariant[];
+      brunoRequest.body.ws = variants.map((variant, index) => ({
+        name: variant.title || `message ${index + 1}`,
+        type: variant.message?.type || 'text',
+        content: ensureString(variant.message?.data),
+        selected: variant.selected || false
+      }));
+    } else {
+      // single message uses flat WebSocketMessage
+      const message = websocket.message as WebSocketMessage;
+      const messageData = ensureString(message.data);
+      if (messageData.trim().length) {
+        brunoRequest.body.ws = [{
+          name: '',
+          type: message.type || 'text',
+          content: messageData
+        }];
+      }
     }
   }
 
@@ -101,6 +113,14 @@ const parseWebsocketRequest = (ocRequest: WebSocketRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   return brunoItem;
 };
 

package/src/formats/yml/items/stringifyApp.ts

@@ -0,0 +1,45 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import { stringifyYml } from '../utils';
+
+interface AppFileInfo {
+  name: string;
+  type: 'app';
+  seq?: number;
+  tags?: string[];
+}
+
+interface AppFile {
+  info: AppFileInfo;
+  code?: string;
+}
+
+// Mirror the request shape (info.name/type/seq/tags + body) so apps round-trip
+// the same fields and can be reordered via seq like every other item.
+const stringifyApp = (item: BrunoItem): string => {
+  try {
+    const info: AppFileInfo = {
+      name: item.name && item.name.trim().length ? item.name : 'App',
+      type: 'app'
+    };
+    if (typeof item.seq === 'number') {
+      info.seq = item.seq;
+    }
+    if (Array.isArray(item.tags) && item.tags.length) {
+      info.tags = item.tags;
+    }
+
+    const ocApp: AppFile = { info };
+
+    const code = item.app?.code;
+    if (code && code.trim().length) {
+      ocApp.code = code;
+    }
+
+    return stringifyYml(ocApp);
+  } catch (error) {
+    console.error('Error stringifying app:', error);
+    throw error;
+  }
+};
+
+export default stringifyApp;

package/src/formats/yml/items/stringifyGraphQLRequest.ts

@@ -33,6 +33,9 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // graphql block

package/src/formats/yml/items/stringifyGrpcRequest.ts

@@ -1,7 +1,7 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
 import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
-import type { GrpcRequest, GrpcMetadata, GrpcMessage, GrpcRequestInfo, GrpcRequestDetails, GrpcRequestRuntime } from '@opencollection/types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata, GrpcMessageVariant, GrpcMessage, GrpcRequestInfo, GrpcRequestDetails, GrpcRequestRuntime } from '@opencollection/types/requests/grpc';
 import type { Auth } from '@opencollection/types/common/auth';
 import type { Scripts } from '@opencollection/types/common/scripts';
 import type { Variable } from '@opencollection/types/common/variables';
@@ -29,6 +29,9 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // grpc block
@@ -73,16 +76,11 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
 
     // message
     if (brunoRequest.body?.mode === 'grpc' && brunoRequest.body.grpc?.length) {
-      const messages = brunoRequest.body.grpc;
-
-      // todo: bruno app supports only one message for now
-      // update this when bruno app supports multiple messages
-      if (messages.length) {
-        const message: GrpcMessage = messages[0].content || '';
-        if (message.trim().length) {
-          grpc.message = message;
-        }
-      }
+      const messages: GrpcMessageVariant[] = brunoRequest.body.grpc.map(({ name, content }, index) => ({
+        title: name || `message ${index + 1}`,
+        message: content || ''
+      }));
+      grpc.message = messages;
     }
 
     // auth