attio 0.0.1-experimental.20250829 → 0.0.1-experimental.20250829.1

package/lib/build/client/generate-client-entry.js

@@ -1,79 +1,76 @@
 import fs from "fs/promises";
 import path from "path";
-import { complete, errored } from "@attio/fetchable-npm";
-import { findSurfaceExports } from "../../util/find-surface-exports/find-surface-exports.js";
+import { Project } from "ts-morph";
+import { complete, errored, fromPromise, isComplete } from "@attio/fetchable-npm";
+import { getAppEntryPoint } from "../../util/get-app-entry-point.js";
 const ASSET_FILE_EXTENSIONS = ["png"];
 export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }) {
-    let surfaceExports;
-    try {
-        surfaceExports = await findSurfaceExports(srcDirAbsolute);
-    }
-    catch (error) {
+    const appEntryPoint = await getAppEntryPoint(srcDirAbsolute);
+    if (!appEntryPoint) {
         return errored({
-            code: "ERROR_FINDING_SURFACE_EXPORTS",
-            error,
+            code: "APP_ENTRY_POINT_NOT_FOUND",
         });
     }
-    let assetFiles;
-    try {
-        assetFiles = await fs.readdir(assetsDirAbsolute, { recursive: true });
-    }
-    catch {
-        assetFiles = [];
+    const tsProject = new Project({
+        useInMemoryFileSystem: true,
+    });
+    const appSourceFile = tsProject.createSourceFile(appEntryPoint.path, appEntryPoint.content);
+    const exported = appSourceFile.getExportedDeclarations();
+    const hasAppExport = exported.has("app");
+    if (!hasAppExport) {
+        return errored({
+            code: "APP_EXPORT_NOT_FOUND",
+            path: appEntryPoint.path,
+        });
     }
+    const assetFilesResult = await fromPromise(fs.readdir(assetsDirAbsolute, { recursive: true }));
+    const assetFiles = isComplete(assetFilesResult) ? assetFilesResult.value : [];
     const assets = assetFiles
         .filter((relativeAssetPath) => ASSET_FILE_EXTENSIONS.some((extension) => relativeAssetPath.endsWith("." + extension)))
         .map((relativeAssetPath) => ({
         path: path.join(assetsDirAbsolute, relativeAssetPath),
         name: relativeAssetPath,
     }));
-    const importSurfacesJS = surfaceExports
-        .map(([filePath, actionKinds], index) => `import {${actionKinds
-        .map((actionKind) => `${actionKind} as ${actionKind}${index}`)
-        .join(", ")}} from ${JSON.stringify(filePath)};`)
-        .join("\n");
-    const surfaceImportNamesBySurfaceType = {
-        recordAction: [],
-        bulkRecordAction: [],
-        recordWidget: [],
-        callRecordingInsightTextSelectionAction: [],
-        callRecordingSummaryTextSelectionAction: [],
-        callRecordingTranscriptTextSelectionAction: [],
-        workflowBlock: [],
-    };
-    surfaceExports.forEach(([, surfaceNames], index) => {
-        surfaceNames.forEach((surfaceName) => {
-            surfaceImportNamesBySurfaceType[surfaceName].push(`${surfaceName}${index}`);
-        });
-    });
-    const registerSurfacesJS = `registerSurfaces({
-  "record-action": [${surfaceImportNamesBySurfaceType.recordAction.join(", ")}],
-  "bulk-record-action": [${surfaceImportNamesBySurfaceType.bulkRecordAction.join(", ")}],
-  "record-widget": [${surfaceImportNamesBySurfaceType.recordWidget.join(", ")}],
-  "call-recording-insight-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingInsightTextSelectionAction.join(", ")}],
-  "call-recording-summary-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingSummaryTextSelectionAction.join(", ")}],
-  "call-recording-transcript-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingTranscriptTextSelectionAction.join(", ")}],
-  "workflow-block": [${surfaceImportNamesBySurfaceType.workflowBlock.join(", ")}]
-});`;
+    const importAppJS = `
+        import {app} from ${JSON.stringify(appEntryPoint.path)}
+    `;
+    const registerSurfacesJS = `
+        const recordActions = app?.record?.actions
+        const bulkRecordActions = app?.record?.bulkActions
+        const recordWidgets = app?.record?.widgets
+        const callRecordingInsights = app?.callRecording?.insight?.textActions
+        const callRecordingSummaries = app?.callRecording?.summary?.textActions
+        const callRecordingTranscripts = app?.callRecording?.transcript?.textActions
+        const workflowBlocks = app?.workflow?.blocks
+
+        registerSurfaces({
+            "record-action": Array.isArray(recordActions) ? recordActions : [],
+            "bulk-record-action": Array.isArray(bulkRecordActions) ? bulkRecordActions : [],
+            "record-widget":  Array.isArray(recordWidgets) ? recordWidgets : [],
+            "call-recording-insight-text-selection-action":  Array.isArray(callRecordingInsights) ? callRecordingInsights : [],
+            "call-recording-summary-text-selection-action":  Array.isArray(callRecordingSummaries) ? callRecordingSummaries : [],
+            "call-recording-transcript-text-selection-action":  Array.isArray(callRecordingTranscripts) ? callRecordingTranscripts : [],
+            "workflow-block":  Array.isArray(workflowBlocks) ? workflowBlocks : [],
+        })
+    `;
     const importAssetsJS = assets
         .map((asset, index) => `import A${index} from ${JSON.stringify(asset.path)};`)
         .join("\n");
     const registerAssetsJS = `
-const assets = [];
+        const assets = [];
 
- ${assets
+         ${assets
         .map((asset, index) => `assets.push({name: ${JSON.stringify(asset.name)}, data: A${index}});`)
         .join("\n")}
 
-registerAssets(assets);
-`;
+        registerAssets(assets);
+    `;
     return complete(`
-${importSurfacesJS}
-
-${importAssetsJS}
+        ${importAppJS}
+        ${importAssetsJS}
 
-${registerSurfacesJS}
+        ${registerSurfacesJS}
 
-${registerAssetsJS}
-`);
+        ${registerAssetsJS}
+    `);
 }

package/lib/build/client/legacy-generate-client-entry.js

@@ -0,0 +1,79 @@
+import fs from "fs/promises";
+import path from "path";
+import { complete, errored } from "@attio/fetchable-npm";
+import { findSurfaceExports } from "../../util/find-surface-exports/find-surface-exports.js";
+const ASSET_FILE_EXTENSIONS = ["png"];
+export async function legacyGenerateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }) {
+    let surfaceExports;
+    try {
+        surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    }
+    catch (error) {
+        return errored({
+            code: "ERROR_FINDING_SURFACE_EXPORTS",
+            error,
+        });
+    }
+    let assetFiles;
+    try {
+        assetFiles = await fs.readdir(assetsDirAbsolute, { recursive: true });
+    }
+    catch {
+        assetFiles = [];
+    }
+    const assets = assetFiles
+        .filter((relativeAssetPath) => ASSET_FILE_EXTENSIONS.some((extension) => relativeAssetPath.endsWith("." + extension)))
+        .map((relativeAssetPath) => ({
+        path: path.join(assetsDirAbsolute, relativeAssetPath),
+        name: relativeAssetPath,
+    }));
+    const importSurfacesJS = surfaceExports
+        .map(([filePath, surfaces], index) => `import {${surfaces
+        .map((surface) => `${surface.surfaceType} as ${surface.surfaceType}${index}`)
+        .join(", ")}} from ${JSON.stringify(filePath)};`)
+        .join("\n");
+    const surfaceImportNamesBySurfaceType = {
+        recordAction: [],
+        bulkRecordAction: [],
+        recordWidget: [],
+        callRecordingInsightTextSelectionAction: [],
+        callRecordingSummaryTextSelectionAction: [],
+        callRecordingTranscriptTextSelectionAction: [],
+        workflowBlock: [],
+    };
+    surfaceExports.forEach(([, surfaces], index) => {
+        surfaces.forEach((surface) => {
+            surfaceImportNamesBySurfaceType[surface.surfaceType].push(`${surface.surfaceType}${index}`);
+        });
+    });
+    const registerSurfacesJS = `registerSurfaces({
+  "record-action": [${surfaceImportNamesBySurfaceType.recordAction.join(", ")}],
+  "bulk-record-action": [${surfaceImportNamesBySurfaceType.bulkRecordAction.join(", ")}],
+  "record-widget": [${surfaceImportNamesBySurfaceType.recordWidget.join(", ")}],
+  "call-recording-insight-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingInsightTextSelectionAction.join(", ")}],
+  "call-recording-summary-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingSummaryTextSelectionAction.join(", ")}],
+  "call-recording-transcript-text-selection-action": [${surfaceImportNamesBySurfaceType.callRecordingTranscriptTextSelectionAction.join(", ")}],
+  "workflow-block": [${surfaceImportNamesBySurfaceType.workflowBlock.join(", ")}]
+});`;
+    const importAssetsJS = assets
+        .map((asset, index) => `import A${index} from ${JSON.stringify(asset.path)};`)
+        .join("\n");
+    const registerAssetsJS = `
+const assets = [];
+
+ ${assets
+        .map((asset, index) => `assets.push({name: ${JSON.stringify(asset.name)}, data: A${index}});`)
+        .join("\n")}
+
+registerAssets(assets);
+`;
+    return complete(`
+${importSurfacesJS}
+
+${importAssetsJS}
+
+${registerSurfacesJS}
+
+${registerAssetsJS}
+`);
+}

package/lib/commands/build.js

@@ -1,5 +1,8 @@
 import { Command } from "commander";
 import { isErrored } from "@attio/fetchable-npm";
+import { USE_APP_TS } from "../env.js";
+import { ensureAppEntryPoint } from "../util/ensure-app-entry-point.js";
+import { exitWithMissingEntryPoint } from "../util/exit-with-missing-entry-point.js";
 import { hardExit } from "../util/hard-exit.js";
 import { spinnerify } from "../util/spinner.js";
 import { printJsError, printTsError } from "../util/typescript.js";
@@ -10,6 +13,12 @@ import { printBuildContextError } from "./dev/prepare-build-contexts.js";
 export const build = new Command("build")
     .description("Build your Attio extension locally")
     .action(async () => {
+    if (USE_APP_TS) {
+        const appEntryPointResult = await ensureAppEntryPoint();
+        if (isErrored(appEntryPointResult)) {
+            exitWithMissingEntryPoint();
+        }
+    }
     const generateGraphqlOperationsResult = await spinnerify("Generating GraphQL types...", "GraphQL types generated successfully", graphqlCodeGen);
     if (isErrored(generateGraphqlOperationsResult)) {
         hardExit(generateGraphqlOperationsResult.error.error.toString());

package/lib/commands/dev/prepare-build-contexts.js

@@ -6,9 +6,11 @@ import tmp from "tmp-promise";
 import { combineAsync, complete, errored, isErrored } from "@attio/fetchable-npm";
 import { createClientBuildConfig } from "../../build/client/create-client-build-config.js";
 import { generateClientEntry } from "../../build/client/generate-client-entry.js";
+import { legacyGenerateClientEntry } from "../../build/client/legacy-generate-client-entry.js";
 import { createServerBuildConfig } from "../../build/server/create-server-build-config.js";
 import { generateServerEntry } from "../../build/server/generate-server-entry.js";
 import { errorsAndWarningsSchema } from "../../build.js";
+import { USE_APP_TS } from "../../env.js";
 export async function prepareBuildContexts(mode) {
     const srcDir = "src";
     const assetsDir = path.join(srcDir, "assets");
@@ -20,10 +22,15 @@ export async function prepareBuildContexts(mode) {
             .then(async (tempFile) => {
             let lastJS;
             const updateTempFile = async () => {
-                const jsResult = await generateClientEntry({
-                    srcDirAbsolute: path.resolve(srcDir),
-                    assetsDirAbsolute: path.resolve(assetsDir),
-                });
+                const jsResult = USE_APP_TS
+                    ? await generateClientEntry({
+                        srcDirAbsolute: path.resolve(srcDir),
+                        assetsDirAbsolute: path.resolve(assetsDir),
+                    })
+                    : await legacyGenerateClientEntry({
+                        srcDirAbsolute: path.resolve(srcDir),
+                        assetsDirAbsolute: path.resolve(assetsDir),
+                    });
                 if (isErrored(jsResult)) {
                     return jsResult;
                 }
@@ -65,7 +72,10 @@ export async function prepareBuildContexts(mode) {
             }
             return complete({
                 rebuild: async () => {
-                    await updateTempFile();
+                    const updateResult = await updateTempFile();
+                    if (isErrored(updateResult)) {
+                        return updateResult;
+                    }
                     try {
                         return complete(await esbuildContext.rebuild());
                     }
@@ -197,6 +207,12 @@ export function printBuildContextError(error) {
         case "ERROR_FINDING_SURFACE_EXPORTS":
             process.stderr.write(`${chalk.red("✖ ")}Failed to find surface exports: ${error.error}\n`);
             break;
+        case "APP_ENTRY_POINT_NOT_FOUND":
+            process.stderr.write(`${chalk.red("✖ ")}Could not find app.ts\n`);
+            break;
+        case "APP_EXPORT_NOT_FOUND":
+            process.stderr.write(`${chalk.red("✖ ")}Could not find a named export "app" in ${path.basename(error.path)}.\n`);
+            break;
         case "UNPARSABLE_BUILD_ERROR":
             process.stderr.write(`${chalk.red("✖ ")}Failed to parse build error: ${error.error}\n`);
             break;

package/lib/commands/dev.js

@@ -4,7 +4,10 @@ import notifier from "node-notifier";
 import { z } from "zod";
 import { isErrored } from "@attio/fetchable-npm";
 import { authenticator } from "../auth/auth.js";
+import { USE_APP_TS } from "../env.js";
 import { printUploadError } from "../print-errors.js";
+import { ensureAppEntryPoint } from "../util/ensure-app-entry-point.js";
+import { hardExit } from "../util/hard-exit.js";
 import { printMessage } from "../util/print-message.js";
 import { printJsError, printTsError } from "../util/typescript.js";
 import { boot } from "./dev/boot.js";
@@ -46,6 +49,17 @@ export const dev = new Command("dev")
     const { workspace: workspaceSlug } = optionsSchema.parse(unparsedOptions);
     const cleanupFunctions = [];
     let isCleaningUp = false;
+    if (USE_APP_TS) {
+        const appEntryPointResult = await ensureAppEntryPoint(true);
+        if (isErrored(appEntryPointResult)) {
+            switch (appEntryPointResult.error.code) {
+                case "APP_ENTRY_POINT_NOT_FOUND":
+                    hardExit("Could not find app.ts");
+                case "FAILED_TO_GENERATE_ENTRY_POINT":
+                    hardExit("Failed to generate app.ts");
+            }
+        }
+    }
     await authenticator.ensureAuthed();
     const cleanup = async () => {
         if (isCleaningUp)
@@ -98,18 +112,18 @@ export const dev = new Command("dev")
             process.stderr.write(error);
         });
         cleanupFunctions.push(cleanupGraphqlCodeGen);
-        let haveJsErrors = false;
+        let haveBundlingErrors = false;
         const cleanupJs = bundleJavaScript(async (contents) => {
-            if (haveJsErrors) {
-                process.stdout.write(`${chalk.green("✓")} JavaScript errors fixed\n`);
-                haveJsErrors = false;
+            if (haveBundlingErrors) {
+                process.stdout.write(`${chalk.green("✓")} Bundling errors fixed\n`);
+                haveBundlingErrors = false;
             }
             const uploadResult = await upload({ contents, devVersionId, appId });
             if (isErrored(uploadResult)) {
                 printUploadError(uploadResult.error);
             }
         }, async (error) => {
-            haveJsErrors = true;
+            haveBundlingErrors = true;
             if (error.code === "BUILD_JAVASCRIPT_ERROR") {
                 notifyJsErrors(error);
                 const { errors, warnings } = error;

package/lib/commands/version/create.js

@@ -3,10 +3,13 @@ import { Command } from "commander";
 import { combineAsync, isErrored } from "@attio/fetchable-npm";
 import { api } from "../../api/api.js";
 import { authenticator } from "../../auth/auth.js";
+import { USE_APP_TS } from "../../env.js";
 import { printCliVersionError, printFetcherError, printPackageJsonError } from "../../print-errors.js";
 import { getAppInfo } from "../../spinners/get-app-info.spinner.js";
 import { getAppSlugFromPackageJson } from "../../spinners/get-app-slug-from-package-json.js";
 import { getVersions } from "../../spinners/get-versions.spinner.js";
+import { ensureAppEntryPoint } from "../../util/ensure-app-entry-point.js";
+import { exitWithMissingEntryPoint } from "../../util/exit-with-missing-entry-point.js";
 import { loadAttioCliVersion } from "../../util/load-attio-cli-version.js";
 import { spinnerify } from "../../util/spinner.js";
 import { printJsError } from "../../util/typescript.js";
@@ -16,6 +19,12 @@ import { bundleJavaScript } from "./create/bundle-javascript.js";
 export const versionCreate = new Command("create")
     .description("Create a new unpublished version of your Attio app")
     .action(async () => {
+    if (USE_APP_TS) {
+        const appEntryPointResult = await ensureAppEntryPoint();
+        if (isErrored(appEntryPointResult)) {
+            exitWithMissingEntryPoint();
+        }
+    }
     await authenticator.ensureAuthed();
     const appSlugResult = await getAppSlugFromPackageJson();
     if (isErrored(appSlugResult)) {

package/lib/env.js

@@ -3,3 +3,4 @@ const DOMAIN = `attio.${IS_DEV ? "me" : "com"}`;
 export const API = `https://build.${DOMAIN}/api`;
 export const APP_NO_PROTOCOL = `app.${DOMAIN}`;
 export const APP = `https://${APP_NO_PROTOCOL}`;
+export const USE_APP_TS = process.env.USE_APP_TS === "true";

package/lib/util/ensure-app-entry-point.js

@@ -0,0 +1,30 @@
+import path from "path";
+import readline from "readline/promises";
+import { complete, errored, isErrored } from "@attio/fetchable-npm";
+import { generateAppEntryPoint } from "./generate-app-entry-point.js";
+import { getAppEntryPoint } from "./get-app-entry-point.js";
+export async function ensureAppEntryPoint(promptToGenerate = false) {
+    const srcDirAbsolute = path.resolve("src");
+    const appEntryPoint = await getAppEntryPoint(srcDirAbsolute);
+    if (appEntryPoint !== null) {
+        return complete(true);
+    }
+    if (!promptToGenerate) {
+        return errored({
+            code: "APP_ENTRY_POINT_NOT_FOUND",
+        });
+    }
+    let readlineInterface = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    await readlineInterface.question("Could not find app.ts entry point. Press Enter to generate it...");
+    readlineInterface.close();
+    const generateResult = await generateAppEntryPoint(srcDirAbsolute);
+    if (isErrored(generateResult)) {
+        return errored({
+            code: "FAILED_TO_GENERATE_ENTRY_POINT",
+        });
+    }
+    return complete(true);
+}

package/lib/util/exit-with-missing-entry-point.js

@@ -0,0 +1,11 @@
+import { hardExit } from "./hard-exit.js";
+export function exitWithMissingEntryPoint() {
+    const packageManager = process.env.npm_config_user_agent?.split("/")?.[0];
+    const command = {
+        npm: "npm run dev",
+        yarn: "yarn dev",
+        pnpm: "pnpm dev",
+        bun: "bun run dev",
+    }[packageManager ?? "npm"] ?? "npm run dev";
+    hardExit(`Could not find app.ts. Run \`${command}\` to generate it`);
+}

package/lib/util/find-surface-exports/parse-file-exports.js

@@ -14,8 +14,8 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
         return aliasedSymbol ?? declarationSymbol;
     }
     const declarationsByName = sourceFile.getExportedDeclarations();
-    for (const surfaceName of SURFACE_TYPES) {
-        const declarations = declarationsByName.get(surfaceName);
+    for (const surfaceType of SURFACE_TYPES) {
+        const declarations = declarationsByName.get(surfaceType);
         if (!declarations) {
             continue;
         }
@@ -27,12 +27,12 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
         }
         const exportType = declaration.getType();
         if (isTypeScript(sourceFile) &&
-            !typeChecker.isTypeAssignableTo(exportType, surfaceTypes[surfaceName])) {
+            !typeChecker.isTypeAssignableTo(exportType, surfaceTypes[surfaceType])) {
             const node = declaration.getFirstChild() || declaration;
             throw {
                 errors: [
                     {
-                        text: `${surfaceName} in ${filePath} is not assignable to ${getSurfaceTypeName(surfaceName)}`,
+                        text: `${surfaceType} in ${filePath} is not assignable to ${getSurfaceTypeName(surfaceType)}`,
                         location: {
                             file: filePath,
                             line: node.getStartLineNumber(),
@@ -40,8 +40,8 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
                             lineText: declaration.getText().split("\n")[0],
                             additionalLines: declaration.getText().split("\n").slice(1),
                             length: node.getWidth(),
-                            namespace: surfaceName,
-                            suggestion: `Ensure the export matches the type ${getSurfaceTypeName(surfaceName)}`,
+                            namespace: surfaceType,
+                            suggestion: `Ensure the export matches the type ${getSurfaceTypeName(surfaceType)}`,
                         },
                     },
                 ],
@@ -49,24 +49,24 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
         }
         function getPropertyValueOrThrow(propertyName) {
             if (declaration.getKind() !== SyntaxKind.VariableDeclaration) {
-                throw new Error(`${surfaceName} is not an object in ${filePath} ${declaration.getKind()}`);
+                throw new Error(`${surfaceType} is not an object in ${filePath} ${declaration.getKind()}`);
             }
             const initializer = declaration
                 .asKindOrThrow(SyntaxKind.VariableDeclaration)
                 .getInitializer();
             if (initializer?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-                throw new Error(`${surfaceName} must be defined as an object literal expression in ${filePath}`);
+                throw new Error(`${surfaceType} must be defined as an object literal expression in ${filePath}`);
             }
             const objectLiteral = initializer.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
             const property = objectLiteral.getProperty(propertyName);
             if (property?.getKind() !== SyntaxKind.PropertyAssignment) {
-                throw new Error(`Property ${propertyName} on ${surfaceName} must be directly declared in the object declaration in ${filePath}`);
+                throw new Error(`Property ${propertyName} on ${surfaceType} must be directly declared in the object declaration in ${filePath}`);
             }
             const propertyInitializer = property
                 .asKindOrThrow(SyntaxKind.PropertyAssignment)
                 .getInitializer();
             if (propertyInitializer?.getKind() !== SyntaxKind.StringLiteral) {
-                throw new Error(`Property ${propertyName} on ${surfaceName} must be a string literal in ${filePath}`);
+                throw new Error(`Property ${propertyName} on ${surfaceType} must be a string literal in ${filePath}`);
             }
             return propertyInitializer.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
         }
@@ -83,7 +83,7 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
                             length: declaration.getWidth(),
                             lineText: declaration.getText().split("\n")[0],
                             additionalLines: declaration.getText().split("\n").slice(1),
-                            namespace: surfaceName,
+                            namespace: surfaceType,
                             suggestion: `Ensure the id is unique`,
                         },
                     },
@@ -92,7 +92,7 @@ export function parseFileExports({ sourceFile, existingExportSymbols, existingId
         }
         existingExportSymbols.add(originalSymbol);
         existingIds.add(surfaceId);
-        surfaceExports.add(surfaceName);
+        surfaceExports.add({ surfaceType, id: surfaceId });
     }
     return surfaceExports;
 }

package/lib/util/generate-app-entry-point.js

@@ -0,0 +1,75 @@
+import fs from "fs/promises";
+import path from "path";
+import { complete, fromPromise, isErrored } from "@attio/fetchable-npm";
+import { findSurfaceExports } from "./find-surface-exports/find-surface-exports.js";
+import { SURFACE_TYPES } from "./surfaces.js";
+import { toCamelCase } from "./to-camel-case.js";
+export async function generateAppEntryPoint(srcDirAbsolute) {
+    const surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    const surfaceImportFilesByType = SURFACE_TYPES.reduce((surfaceExports, surfaceType) => {
+        surfaceExports[surfaceType] = [];
+        return surfaceExports;
+    }, {});
+    for (const [filePath, surfaces] of surfaceExports) {
+        for (const surface of surfaces) {
+            surfaceImportFilesByType[surface.surfaceType].push({
+                importPath: getRelativeImportPath(srcDirAbsolute, filePath),
+                id: surface.id,
+            });
+        }
+    }
+    const appImportStatement = `import type {App} from "attio/client"`;
+    const surfaceImportsStatements = SURFACE_TYPES.flatMap((surfaceType) => {
+        const surfaceImports = surfaceImportFilesByType[surfaceType];
+        return surfaceImports.map((surface) => {
+            const surfaceName = getSurfaceImportName(surface.id);
+            return `import {${surfaceType}${surfaceName !== surfaceType ? ` as ${surfaceName}` : ""}} from ${JSON.stringify(surface.importPath)}`;
+        });
+    }).join("\n");
+    const getSurfaceNamesArray = (surfaceType) => {
+        const surfaceImports = surfaceImportFilesByType[surfaceType];
+        return surfaceImports.map((surface) => getSurfaceImportName(surface.id));
+    };
+    const appExportStatement = `export const app: App = {
+    record: {
+        actions: [${getSurfaceNamesArray("recordAction").join(",")}],
+        bulkActions: [${getSurfaceNamesArray("bulkRecordAction").join(",")}],
+        widgets: [${getSurfaceNamesArray("recordWidget").join(",")}],
+    },
+    callRecording: {
+        insight: {
+            textActions: [${getSurfaceNamesArray("callRecordingInsightTextSelectionAction")}]
+        },
+        summary: {
+            textActions: [${getSurfaceNamesArray("callRecordingSummaryTextSelectionAction")}]
+        },
+        transcript: {
+            textActions: [${getSurfaceNamesArray("callRecordingTranscriptTextSelectionAction")}]
+        },
+    },
+}`;
+    const appEntryPointContent = [
+        appImportStatement,
+        surfaceImportsStatements,
+        appExportStatement,
+    ].join("\n\n");
+    const writeResult = await fromPromise(fs.writeFile(path.join(srcDirAbsolute, "app.ts"), appEntryPointContent));
+    if (isErrored(writeResult)) {
+        return writeResult;
+    }
+    return complete(true);
+}
+function getRelativeImportPath(dir, filePath) {
+    const relativePath = path
+        .relative(dir, filePath)
+        .split(path.sep)
+        .join("/")
+        .replace(/\.[^/.]+$/, "");
+    if (relativePath.startsWith(".")) {
+        return relativePath;
+    }
+    return `./${relativePath}`;
+}
+function getSurfaceImportName(surfaceId) {
+    return toCamelCase(surfaceId);
+}

package/lib/util/get-app-entry-point.js

@@ -0,0 +1,18 @@
+import fs from "fs/promises";
+import path from "path";
+import { fromPromise, isErrored } from "@attio/fetchable-npm";
+const APP_ENTRY_POINT_EXTENSIONS = ["ts", "tsx"];
+export async function getAppEntryPoint(srcDirAbsolute) {
+    const appEntryPoints = await Promise.all(APP_ENTRY_POINT_EXTENSIONS.map(async (extension) => {
+        const filePath = path.join(srcDirAbsolute, `app.${extension}`);
+        const contentResult = await fromPromise(fs.readFile(filePath));
+        if (isErrored(contentResult)) {
+            return null;
+        }
+        return {
+            path: filePath,
+            content: contentResult.value.toString(),
+        };
+    }));
+    return appEntryPoints.find((entryPoint) => entryPoint !== null) ?? null;
+}

package/lib/util/to-camel-case.js

@@ -0,0 +1,13 @@
+export function toCamelCase(input) {
+    return input
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .trim()
+        .split(" ")
+        .map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join("");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250829",
+  "version": "0.0.1-experimental.20250829.1",
   "type": "module",
   "files": [
     "lib",