Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import {
type AnyBlockDefinition,
type BlockAlias,
type BlockName,
BlockRegistry,
type FileTypeString,
type MimeType,
} from '@core/block';
import type { SubType } from '@entity';
import type { ItemType } from '@service-storage/client';
import type { BasicDocumentSubTypeProperty } from '@service-storage/generated/schemas';
import type { BasicDocumentFileType } from '@service-storage/generated/schemas/basicDocumentFileType';
import {
ENABLE_DOCX_TO_PDF,
enableDocxEditor,
isFeatureEnabled,
} from './featureFlags';
import { DefaultFilename } from './filename';
const discoveredBlockDefinitions = Object.values<AnyBlockDefinition>(
import.meta.glob('../../../features/*/definition.ts', {
eager: true,
import: 'definition',
})
);
const definitionNames = discoveredBlockDefinitions.map(
(definition) => definition.name
);
const duplicateDefinitionNames = definitionNames.filter(
(name, index) => definitionNames.indexOf(name) !== index
);
if (duplicateDefinitionNames.length > 0) {
throw new Error(
`Duplicate block definitions discovered: ${[...new Set(duplicateDefinitionNames)].join(', ')}`
);
}
// Every block needs a module. `write` (DOCX) is the collaborative DOCX editor
// when it is enabled; otherwise `verifyBlockName` resolves it to `pdf`.
const missingBlockDefinitions = BlockRegistry.filter(
(name) => !definitionNames.includes(name)
);
if (missingBlockDefinitions.length > 0) {
throw new Error(
`Missing block definitions: ${missingBlockDefinitions.join(', ')}`
);
}
export const blocks = Object.fromEntries(
discoveredBlockDefinitions.map((definition) => [definition.name, definition])
) as Readonly<Record<BlockName, Readonly<AnyBlockDefinition>>>;
export const blockAcceptedMimetypeToFileExtension: Record<
MimeType,
FileTypeString
> = {};
export const blockAcceptedFileExtensionToMimeType: Record<
FileTypeString,
MimeType
> = {};
const fileTypeToBlockName_: Record<string, BlockName> = {};
// Map from alias names to their base block names
const aliasToBlockName_: Record<string, BlockName> = {};
// Map from base block names to their aliases
const blockNameToAliases: Partial<Record<BlockName, string[]>> = {};
export const blockAcceptedFileExtensionSet = new Set<string>();
// @ts-ignore This type is built below
export const blockNameToFileExtensionSet: Record<
BlockName,
Set<FileTypeString>
> = {};
// @ts-ignore This type is built below
const blockNameToMimeTypeSet: Record<BlockName, Set<MimeType>> = {};
const blockNameToDefaultFilename: Partial<
Record<BlockName | BlockAlias, string>
> = {};
for (const [name, block] of Object.entries(blocks)) {
blockNameToFileExtensionSet[name as BlockName] = new Set();
blockNameToMimeTypeSet[name as BlockName] = new Set();
// Process aliases
if (block.aliases) {
blockNameToAliases[name as BlockName] = block.aliases.map(
(alias) => alias.name
);
for (const alias of block.aliases) {
aliasToBlockName_[alias.name] = name as BlockName;
if (alias.defaultFileName) {
blockNameToDefaultFilename[alias.name] = alias.defaultFileName;
}
}
} else {
blockNameToAliases[name as BlockName] = [];
}
for (const [fileExtension, mimeType] of Object.entries(block.accepted)) {
fileTypeToBlockName_[fileExtension] = name as BlockName;
blockAcceptedFileExtensionSet.add(fileExtension);
blockNameToFileExtensionSet[name as BlockName].add(fileExtension);
if (!mimeType) continue;
// first instance wins for now
blockAcceptedMimetypeToFileExtension[mimeType] ??= fileExtension;
blockNameToMimeTypeSet[name as BlockName].add(mimeType);
blockAcceptedFileExtensionToMimeType[fileExtension] ??= mimeType;
}
if (block.defaultFilename) {
blockNameToDefaultFilename[name as BlockName] = block.defaultFilename;
}
}
function _blockAcceptsMimeType(blockName: BlockName, mimeType: MimeType) {
return blockNameToMimeTypeSet[blockName].has(mimeType);
}
export function blockAcceptsFileExtension(
blockName: BlockName,
fileExtension: string
) {
return blockNameToFileExtensionSet[blockName].has(fileExtension);
}
export const blockNameToFileExtensions = Object.fromEntries(
Object.entries(blockNameToFileExtensionSet).map(([name, extensions]) => [
name,
Array.from(extensions),
])
) as Record<BlockName, string[]>;
export const blockNameToMimeTypes = Object.fromEntries(
Object.entries(blockNameToMimeTypeSet).map(([name, mimeTypes]) => [
name,
Array.from(mimeTypes),
])
) as Record<BlockName, string[]>;
const _blockAcceptedMimeTypes = Object.keys(
blockAcceptedMimetypeToFileExtension
);
const _blockAcceptedFileExtensions = Array.from(blockAcceptedFileExtensionSet);
/**
* Check if a string is a block alias
*/
export function isBlockAlias(name: string): name is BlockAlias {
return name in aliasToBlockName_;
}
/**
* Get the base block name for an alias, or return the original name if not an alias
*/
export function resolveBlockAlias(name: BlockName | BlockAlias): BlockName {
return aliasToBlockName_[name] || (name as BlockName);
}
/**
* Get the name of a block from a its own name or a file type. Built using the
* types registered in block definitions.
* @example
* getBlockName('docx') // 'write'
* getBlockName('svg') // 'image'
* getBlockName('chat') // 'chat'
* getBlockName('task') // 'task'
* getBlockName('junk') // undefined
* @param blockOrFiletype - The block name or file type like 'py', 'md', 'chat',
* 'png', etc.
* @param icon - Whether to return the icon name or the block name. In the case of
* 'docx', icon should still show as docx icon, not pdf.
* @return Either the name of the block or 'unknown' if there is no
* appropriate block.
*/
export function fileTypeToBlockName(
blockOrFiletype?: string | null,
// For docx: icon should still show as docx icon, not pdf
icon?: boolean
): BlockName | BlockAlias {
if (!blockOrFiletype) return 'unknown';
if (blockOrFiletype === 'channel_message') return 'channel';
if (blockOrFiletype === 'agent_session') return 'agent';
if (blockOrFiletype === 'calendar_event') return 'calendar';
if (blockOrFiletype === 'automation') return 'routine';
// CRM entity types map to their dedicated blocks (entity type !== block name).
if (blockOrFiletype === 'crm_company') return 'company';
if (blockOrFiletype === 'crm_contact') return 'contact';
if (blockOrFiletype === 'crm_pipeline') return 'pipeline';
if (blockOrFiletype === 'docx' || blockOrFiletype === 'write') {
if (isFeatureEnabled(enableDocxEditor)) return 'write';
if (ENABLE_DOCX_TO_PDF) return icon ? 'write' : 'pdf';
}
if (isBlockAlias(blockOrFiletype)) {
return blockOrFiletype;
}
if (BlockRegistry.includes(blockOrFiletype as any)) {
return blockOrFiletype as BlockName;
}
return fileTypeToBlockName_[blockOrFiletype] ?? 'unknown';
}
/**
* Get the name of a block from a its own name, aliased name, or a file type.
* @example
* getBlockName('task') // 'md'
* getBlockName('junk') // undefined
* @param blockOrFiletype - The block name or file type like 'py', 'md', 'chat',
* 'png', etc.
* @return Either the name of the block or 'unknown' if there is no
* appropriate block.
*/
export function fileTypeToResolvedBlockName(
blockOrFiletype?: string | null
): BlockName {
return resolveBlockAlias(fileTypeToBlockName(blockOrFiletype));
}
/**
* Get the default display name for an unnamed file of a particular block.
*/
export function blockNameToDefaultFile(block?: BlockName | string | null) {
if (!block) return DefaultFilename;
if (block in blockNameToDefaultFilename) {
return (
blockNameToDefaultFilename[block as BlockName | BlockAlias] ||
DefaultFilename
);
}
return DefaultFilename;
}
export type ItemLike = {
type:
| ItemType
| 'agent'
| 'initiative'
| 'call'
| 'crm_company'
| 'calendar_event'
| 'database';
fileType?: BasicDocumentFileType;
subType?: SubType | BasicDocumentSubTypeProperty;
name?: string;
};
/**
* Get a block name from an item-shaped object.
* @example
* itemToBlockName({ type: 'document', fileType: 'docx' }) // 'write'
* itemToBlockName({ type: 'document', fileType: 'py' }) // 'code'
* itemToBlockName({ type: 'document', fileType: 'md', subType: { type: 'task', is_completed: false } }) // 'task'
* itemToBlockName({ type: 'chat' }) // 'chat'
* @return The block name
*/
export function itemToBlockName(
item: ItemLike,
icon?: boolean
): BlockName | BlockAlias {
const subTypeName =
item.subType && 'type' in item.subType
? (item.subType.type as string)
: undefined;
if (subTypeName && isBlockAlias(subTypeName)) {
return subTypeName;
}
if (item.fileType) {
return fileTypeToBlockName(item.fileType, icon);
}
if (item.type === 'agent_session') return 'agent';
if (item.type === 'channel_thread') return 'channel';
return fileTypeToBlockName(item.type, icon);
}
/**
* Get a flattened block name from an item-shaped object. Ignoring any block \
* aliases.
* @example
* itemToBlockName({ type: 'document', fileType: 'md', subType: 'task' }) // 'md'
* @return The block name
*/
export function itemToResolvedBlockName(item: ItemLike) {
const maybeAliased = itemToBlockName(item);
return resolveBlockAlias(maybeAliased);
}
/**
* Get the name of an item or its block-specific fallback name if the name in storage is
* the empty string.
* @example
* itemToSafeName({ type: 'document', fileType: 'md', fileName: 'My Cool Note' }) // 'My Cool Note'
* itemToBlockName({ type: 'document', fileType: 'py' }) // 'Unknown Filename'
* itemToBlockName({ type: 'chat' }) // 'New Chat'
* @return A safe name for the item to display.
*/
export function itemToSafeName(item: ItemLike): string {
if (typeof item.name === 'string' && item.name.length > 0) {
return item.name;
}
return blockNameToDefaultFile(itemToBlockName(item) || 'unknown');
}
/**
* Return name as a known block name if it matches or 'unknown' if not found.
* @returns
*/
export function verifyBlockName(
name: string | undefined
): BlockName | BlockAlias {
if (!name) return 'unknown';
if (name === 'automation') return 'routine';
if (name === 'write') {
if (isFeatureEnabled(enableDocxEditor)) return 'write';
if (ENABLE_DOCX_TO_PDF) return 'pdf';
}
if (isBlockAlias(name)) return name;
if (name && name in blocks) return name as BlockName;
return 'unknown';
}