@notionhq/apps 0.0.12 → 0.0.14

package/src/cli/build.test.ts

@@ -34,6 +34,42 @@ afterEach(async () => {
 });
 
 describe("buildApp", () => {
+	it("emits workflow and block metadata without adding blocks to the Worker", async () => {
+		const root = fixture("custom-block");
+		const { manifest, bundlePath } = await buildApp(root);
+		expect(manifest.capabilities).toEqual([
+			{ type: "workflow", key: "hello", config: { name: "Hello", triggers: [] } },
+			{
+				type: "custom_block",
+				key: "hello",
+				config: {
+					source: {
+						type: "project",
+						path: "./blocks/hello",
+						command: "npx vite build",
+						output: "dist",
+					},
+					manifest: { version: 1, slashCommand: "hello", dataSources: {} },
+				},
+			},
+		]);
+		const worker = await fs.promises.readFile(bundlePath, "utf8");
+		expect(worker).not.toMatch(
+			/custom_block|createCustomBlock|react|createRoot|NotionCustomBlock/,
+		);
+		expect(fs.existsSync(path.join(root, ".notion/blocks.js"))).toBe(false);
+	});
+	it("names the block file when path is missing", async () => {
+		await expect(buildApp(fixture("custom-block-missing-path"))).rejects.toThrow(
+			/hello.ts.*non-empty path/,
+		);
+	});
+	it("rejects a block file that exports a different capability", async () => {
+		await expect(buildApp(fixture("custom-block-wrong-tag"))).rejects.toThrow(
+			/hello.ts.*createCustomBlock/,
+		);
+	});
+
 	it("builds a sync manifest with a Notion-as-Code meetings database", async () => {
 		const { manifest } = await buildApp(example("sync"));
 
@@ -142,6 +178,24 @@ describe("buildApp", () => {
 					name: "GitHub app data",
 					accessLevel: "open",
 				},
+				{
+					type: "page",
+					resourceId: "github-app-private-page",
+					parent: {
+						type: "resourceId",
+						resourceId: "__notion_apps_workspace__",
+					},
+					properties: { title: [["GitHub app home"]] },
+				},
+				{
+					type: "database",
+					resourceId: "github-app-private-database",
+					parent: {
+						type: "resourceId",
+						resourceId: "__notion_apps_workspace__",
+					},
+					dataSources: [],
+				},
 				{
 					type: "database",
 					resourceId: "issues-db",
@@ -162,6 +216,39 @@ describe("buildApp", () => {
 		});
 	});
 
+	it("removes provisioning when a rebuild no longer declares Notion resources", async () => {
+		const root = await fs.promises.mkdtemp(path.join(FIXTURES, "provisioning-rebuild-"));
+		try {
+			await fs.promises.cp(
+				path.join(FIXTURES, "notion-as-code", "src"),
+				path.join(root, "src"),
+				{
+					recursive: true,
+				},
+			);
+			await buildApp(root);
+			const provisioningPath = path.join(root, "dist", "provisioning.json");
+			const provisioning = JSON.parse(await fs.promises.readFile(provisioningPath, "utf8"));
+			expect(provisioning.intents).toEqual(
+				expect.arrayContaining([expect.objectContaining({ resourceId: "issues-db" })]),
+			);
+
+			await fs.promises.rm(path.join(root, "src"), { recursive: true });
+			await fs.promises.cp(path.join(EXAMPLES, "workflow", "src"), path.join(root, "src"), {
+				recursive: true,
+			});
+			const { manifest } = await buildApp(root);
+			expect(manifest.capabilities).toEqual([
+				expect.objectContaining({ type: "workflow", key: "onPageCreated" }),
+			]);
+			await expect(fs.promises.readFile(provisioningPath)).rejects.toMatchObject({
+				code: "ENOENT",
+			});
+		} finally {
+			await fs.promises.rm(root, { recursive: true, force: true });
+		}
+	});
+
 	it("builds a workflow bundle and manifest", async () => {
 		const { manifest, bundlePath, manifestPath } = await buildApp(example("workflow"));
 

package/src/cli/build.ts

@@ -9,9 +9,9 @@ import {
 	type RecordedProvisioning,
 } from "../notion-as-code/provisioning.js";
 import { clearRegisteredPacers } from "../pacer.js";
-import { generateEntry, generateMetadataEntry } from "./codegen.js";
+import { generateEntry, generateMetadataEntry, generateBlocksEntry } from "./codegen.js";
 import { discoverCapabilities, type DiscoveredCapability } from "./discover.js";
-import { extractManifest, extractProvisioning } from "./emit-manifest.js";
+import { extractManifest, extractProvisioning, extractBlockConfigs } from "./emit-manifest.js";
 
 export type BuildResult = {
 	manifest: AppManifest;
@@ -53,11 +53,15 @@ export async function buildApp(projectRoot: string): Promise<BuildResult> {
 		await bundle.close();
 	}
 
-	const manifest = await extractManifest(bundlePath, capabilities);
+	const blockConfigs = await buildBlockDeclarations(projectRoot, capabilities);
+	const manifest = await extractManifest(bundlePath, capabilities, blockConfigs);
 	const manifestPath = path.join(projectRoot, "dist", "manifest.json");
 	await fs.promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, "\t")}\n`);
 
-	await emitProvisioningArtifact(projectRoot, capabilities);
+	await emitProvisioningArtifact(
+		projectRoot,
+		capabilities.filter((capability) => capability.runtime === "worker"),
+	);
 
 	return { manifest, bundlePath, manifestPath };
 }
@@ -68,13 +72,14 @@ async function emitProvisioningArtifact(
 	capabilities: readonly DiscoveredCapability[],
 ): Promise<void> {
 	const entityProvisioning = await buildMetadata(projectRoot, capabilities);
-	if (entityProvisioning.intents.length === 0) return;
+	const provisioningPath = path.join(projectRoot, "dist", "provisioning.json");
+	if (entityProvisioning.intents.length === 0) {
+		await fs.promises.rm(provisioningPath, { force: true });
+		return;
+	}
 
 	const artifact = createProvisioningArtifact(entityProvisioning.intents);
-	await fs.promises.writeFile(
-		path.join(projectRoot, "dist", "provisioning.json"),
-		`${JSON.stringify(artifact, null, "\t")}\n`,
-	);
+	await fs.promises.writeFile(provisioningPath, `${JSON.stringify(artifact, null, "\t")}\n`);
 }
 
 /** Bundle capabilities separately to record their Notion-as-Code declarations without shipping them. */
@@ -110,3 +115,36 @@ async function buildMetadata(
 		await fs.promises.rm(metadataBundlePath, { force: true });
 	}
 }
+
+async function buildBlockDeclarations(
+	projectRoot: string,
+	capabilities: readonly DiscoveredCapability[],
+): Promise<Record<string, unknown>> {
+	if (!capabilities.some((capability) => capability.runtime === "build")) return {};
+	const entryPath = path.join(projectRoot, ".notion", "blocks-entry.ts");
+	const bundlePath = path.join(projectRoot, ".notion", "blocks.js");
+	await fs.promises.writeFile(entryPath, generateBlocksEntry(capabilities));
+	try {
+		const bundle = await rolldown({
+			input: entryPath,
+			platform: "node",
+			external: (id) => !id.startsWith(".") && !path.isAbsolute(id),
+		});
+		try {
+			await bundle.write({ format: "esm", file: bundlePath, codeSplitting: false });
+		} finally {
+			await bundle.close();
+		}
+		return await extractBlockConfigs(bundlePath);
+	} catch (error) {
+		throw new Error(
+			`Failed to read custom block declarations (${capabilities
+				.filter((c) => c.runtime === "build")
+				.map((c) => c.sourcePath)
+				.join(", ")}): ${error instanceof Error ? error.message : String(error)}`,
+			{ cause: error },
+		);
+	} finally {
+		await fs.promises.rm(bundlePath, { force: true });
+	}
+}

package/src/cli/codegen.test.ts

@@ -8,6 +8,7 @@ describe("generateEntry", () => {
 			{
 				type: "workflow",
 				tag: "workflow",
+				runtime: "worker",
 				key: "onPageCreated",
 				sourcePath: "src/workflows/onPageCreated.ts",
 			},
@@ -24,6 +25,7 @@ describe("generateEntry", () => {
 			{
 				type: "sync",
 				tag: "sync",
+				runtime: "worker",
 				key: "issues",
 				sourcePath: "src/syncs/issues.ts",
 			},

package/src/cli/codegen.ts

@@ -11,14 +11,18 @@ export function generateEntry(capabilities: readonly DiscoveredCapability[]): st
 	const imports: string[] = [];
 	const registryEntries = new Map<string, string[]>();
 
-	capabilities.forEach((capability, index) => {
-		const binding = `capability_${index}`;
-		imports.push(`import ${binding} from ${JSON.stringify(`../${capability.sourcePath}`)};`);
+	capabilities
+		.filter((capability) => capability.runtime !== "build")
+		.forEach((capability, index) => {
+			const binding = `capability_${index}`;
+			imports.push(
+				`import ${binding} from ${JSON.stringify(`../${capability.sourcePath}`)};`,
+			);
 
-		const entries = registryEntries.get(capability.type) ?? [];
-		entries.push(`\t\t${JSON.stringify(capability.key)}: ${binding},`);
-		registryEntries.set(capability.type, entries);
-	});
+			const entries = registryEntries.get(capability.type) ?? [];
+			entries.push(`\t\t${JSON.stringify(capability.key)}: ${binding},`);
+			registryEntries.set(capability.type, entries);
+		});
 
 	const registry = Array.from(registryEntries.entries())
 		.map(([type, entries]) => `\t${JSON.stringify(type)}: {\n${entries.join("\n")}\n\t},`)
@@ -70,3 +74,17 @@ ${imports}
 export default finishMetadataRecording(recorder);
 `;
 }
+
+/** Evaluate block declarations only while building, separately from the Worker. */
+export function generateBlocksEntry(capabilities: readonly DiscoveredCapability[]): string {
+	const entries = capabilities.filter((capability) => capability.runtime === "build");
+	return (
+		entries
+			.map(
+				(capability, index) =>
+					`import block_${index} from ${JSON.stringify(`../${capability.sourcePath}`)};`,
+			)
+			.join("\n") +
+		`\nexport const capabilities = { custom_block: {${entries.map((capability, index) => `${JSON.stringify(capability.key)}: block_${index}`).join(",")}} };\n`
+	);
+}

package/src/cli/discover.test.ts

@@ -9,11 +9,21 @@ const EXAMPLES = fileURLToPath(new URL("../../examples/", import.meta.url));
 const FIXTURES = fileURLToPath(new URL("../../test/fixtures/", import.meta.url));
 
 describe("discoverCapabilities", () => {
+	it("discovers custom block declaration files as build-only capabilities", async () => {
+		expect(await discoverCapabilities(path.join(FIXTURES, "custom-block"))).toContainEqual({
+			type: "custom_block",
+			tag: "custom_block",
+			runtime: "build",
+			key: "hello",
+			sourcePath: path.join("src", "customBlocks", "hello.ts"),
+		});
+	});
 	it("discovers workflow files", async () => {
 		await expect(discoverCapabilities(path.join(EXAMPLES, "workflow"))).resolves.toEqual([
 			{
 				type: "workflow",
 				tag: "workflow",
+				runtime: "worker",
 				key: "onPageCreated",
 				sourcePath: path.join("src", "workflows", "onPageCreated.ts"),
 			},
@@ -25,12 +35,14 @@ describe("discoverCapabilities", () => {
 			{
 				type: "sync",
 				tag: "sync",
+				runtime: "worker",
 				key: "issues",
 				sourcePath: path.join("src", "syncs", "issues.ts"),
 			},
 			{
 				type: "sync",
 				tag: "sync",
+				runtime: "worker",
 				key: "notionAsCodeIssues",
 				sourcePath: path.join("src", "syncs", "notionAsCodeIssues.ts"),
 			},

package/src/cli/discover.ts

@@ -12,11 +12,13 @@ export type CapabilityTypeDefinition = {
 	type: CapabilityType;
 	directory: string;
 	tag: string;
+	runtime: "worker" | "build";
 };
 
 export const CAPABILITY_TYPES: readonly CapabilityTypeDefinition[] = [
-	{ type: "workflow", directory: "workflows", tag: "workflow" },
-	{ type: "sync", directory: "syncs", tag: "sync" },
+	{ type: "workflow", directory: "workflows", tag: "workflow", runtime: "worker" },
+	{ type: "sync", directory: "syncs", tag: "sync", runtime: "worker" },
+	{ type: "custom_block", directory: "customBlocks", tag: "custom_block", runtime: "build" },
 ];
 
 /**
@@ -26,6 +28,7 @@ export const CAPABILITY_TYPES: readonly CapabilityTypeDefinition[] = [
 export type DiscoveredCapability = {
 	type: CapabilityType;
 	tag: string;
+	runtime: "worker" | "build";
 	key: string;
 	/** Path to the source file, relative to the project root. */
 	sourcePath: string;
@@ -64,6 +67,7 @@ export async function discoverCapabilities(projectRoot: string): Promise<Discove
 			discovered.push({
 				type: definition.type,
 				tag: definition.tag,
+				runtime: definition.runtime,
 				key: entry.name.slice(0, -".ts".length),
 				sourcePath: path.join("src", definition.directory, entry.name),
 			});

package/src/cli/emit-manifest.ts

@@ -77,7 +77,7 @@ const MANIFEST_SCHEMA = {
 			items: {
 				type: "object",
 				properties: {
-					type: { type: "string", enum: ["workflow", "sync"] },
+					type: { type: "string", enum: ["workflow", "sync", "custom_block"] },
 					key: { type: "string" },
 					config: {},
 				},
@@ -216,6 +216,7 @@ class DatabaseCollector {
 export async function extractManifest(
 	bundlePath: string,
 	capabilities: readonly DiscoveredCapability[],
+	blockConfigs: Record<string, unknown> = {},
 ): Promise<AppManifest> {
 	clearRegisteredPacers();
 	const bundle = await importBundle(bundlePath);
@@ -224,11 +225,15 @@ export async function extractManifest(
 	const primaryKeyByDatabase = new Map<string, string>();
 
 	const capabilityEntries = capabilities.map((capability) => {
-		const tagged = asTagged(registry[capability.type]?.[capability.key]);
+		const tagged = asTagged(
+			capability.runtime === "build"
+				? blockConfigs[capability.key]
+				: registry[capability.type]?.[capability.key],
+		);
 		if (!tagged || tagged._tag !== capability.tag) {
 			throw new Error(
 				`${capability.sourcePath}: default export is not a ${capability.type} — ` +
-					`files under this directory must default-export create${capitalize(capability.type)}(...)`,
+					`files under this directory must default-export create${capability.type === "custom_block" ? "CustomBlock" : capitalize(capability.type)}(...)`,
 			);
 		}
 
@@ -382,3 +387,8 @@ export function assertJsonSafe(value: unknown, path: string): void {
 		if (property !== undefined) assertJsonSafe(property, `${path}.${key}`);
 	}
 }
+
+/** Read the isolated declaration bundle; browser declarations never enter the Worker. */
+export async function extractBlockConfigs(bundlePath: string): Promise<Record<string, unknown>> {
+	return getCapabilityRegistry(await importBundle(bundlePath)).custom_block ?? {};
+}

package/src/cli/index.ts

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import * as path from "node:path";
+import { parseArgs } from "node:util";
+import { build, upload, printBuildOutput, parseUploadsInput } from "@notionhq/custom-blocks/bundle";
 
 import { buildApp } from "./build.js";
 
 const USAGE = `Usage: notion-apps <command>
 
 Commands:
-  build    Build the app in the current directory
+  build          Build the app in the current directory
+  build-blocks   Build browser bundles (--manifest <path> --out <dir>)
+  upload-blocks  Upload browser bundles (--uploads <json>)
 `;
 
 async function main(): Promise<void> {
@@ -24,6 +28,34 @@ async function main(): Promise<void> {
 			);
 			break;
 		}
+		case "build-blocks": {
+			const { values } = parseArgs({
+				args: process.argv.slice(3),
+				options: {
+					manifest: { type: "string" },
+					out: { type: "string" },
+					cwd: { type: "string" },
+				},
+			});
+			if (!values.out) throw new Error("build-blocks requires --out <dir>");
+			printBuildOutput(
+				await build({
+					out: values.out,
+					manifest: values.manifest ?? "dist/manifest.json",
+					cwd: values.cwd,
+				}),
+			);
+			break;
+		}
+		case "upload-blocks": {
+			const { values } = parseArgs({
+				args: process.argv.slice(3),
+				options: { uploads: { type: "string" } },
+			});
+			if (!values.uploads) throw new Error("upload-blocks requires --uploads <json>");
+			console.log(JSON.stringify(await upload(parseUploadsInput(values.uploads))));
+			break;
+		}
 		case undefined:
 		case "help":
 		case "--help":

package/src/confluence.generated.ts

@@ -0,0 +1,109 @@
+// Generated by notion tool-core codegen-script-types --connections. Do not edit.
+import type { ConnectionActionInvoker } from "./connection-actions.js"
+/**
+ * Script input for the "Query Confluence with CQL" effect (`confluence.cqlQuery`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Run a CQL query and return results.
+ */
+export type CqlQueryScriptInput = {
+	/**
+	 * CQL query string. Only read-only queries are supported. Example: type=page AND space=DEV AND text~"deployment"
+	 */
+	query: string
+	/**
+	 * Maximum number of results to return. Defaults to 20.
+	 */
+	maxResults?: number
+}
+
+/**
+ * Canonical Tool Core output for the "Query Confluence with CQL" effect (`confluence.cqlQuery`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type CqlQueryScriptOutput = {
+	results: Array<{
+		id: string
+		title: string
+		blocks: Array<string>
+	}>
+	query: string
+	baseUrl: string
+}
+
+/**
+ * Script input for the "Load Confluence page" effect (`confluence.loadPage`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Load a Confluence page by ID.
+ */
+export type LoadPageScriptInput = {
+	/**
+	 * The Confluence page ID to load.
+	 */
+	pageId: string
+}
+
+/**
+ * Canonical Tool Core output for the "Load Confluence page" effect (`confluence.loadPage`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type LoadPageScriptOutput = {
+	type: "confluence-page"
+	title: string
+	blocks: Array<string>
+	pageId: string
+}
+
+/**
+ * Script input for the "Search Confluence" effect (`confluence.search`),
+ * derived from its Tool Core definition's call_function input projection.
+ *
+ * Search Confluence via the configured connector.
+ */
+export type SearchScriptInput = {
+	/**
+	 * A single, focused question to search for.
+	 */
+	question: string
+	/**
+	 * Brief keywords capturing the core entities.
+	 */
+	keywords?: string
+	/**
+	 * Optional time window. Use only "default", "all_time", a duration matching /^\d+[dwmy]$/ (for example, "7d", "2w", "3m", or "1y"), or a date in "YYYY-MM-DD" format. Do not use natural-language durations or combine units.
+	 */
+	lookback?: string
+}
+
+/**
+ * Canonical Tool Core output for the "Search Confluence" effect (`confluence.search`).
+ * This is the definition's output schema; the effect's script surface may
+ * re-encode it before returning.
+ */
+export type SearchScriptOutput = {
+	results: Array<{
+		id: string
+		title: string
+		path: string
+		text: string
+		lastEdited: string
+		isPrivate: boolean
+		pageId: string
+	}>
+}
+
+export class ConfluenceConnectionClient {
+	constructor(private readonly invoke: ConnectionActionInvoker) {}
+	cqlQuery(args: CqlQueryScriptInput): Promise<CqlQueryScriptOutput> {
+		return this.invoke<CqlQueryScriptOutput>("cqlQuery", args)
+	}
+	loadPage(args: LoadPageScriptInput): Promise<LoadPageScriptOutput> {
+		return this.invoke<LoadPageScriptOutput>("loadPage", args)
+	}
+	search(args: SearchScriptInput): Promise<SearchScriptOutput> {
+		return this.invoke<SearchScriptOutput>("search", args)
+	}
+}

package/src/connection-actions.ts

@@ -0,0 +1,2 @@
+/** @internal Transport used by generated Tool Core provider clients. */
+export type ConnectionActionInvoker = <Result>(action: string, args: object) => Promise<Result>;

package/src/connection-trigger-definitions.generated.ts

@@ -0,0 +1,48 @@
+// Generated by notion tool-core codegen-script-types --connections. Do not edit.
+export const connectionTriggerDefinitions = [
+	{
+		type: "calendar.event.created",
+		provider: "calendar",
+		description: "Triggers immediately when a calendar event is created",
+	},
+	{
+		type: "calendar.event.updated",
+		provider: "calendar",
+		description: "Triggers immediately when a calendar event is updated",
+	},
+	{
+		type: "calendar.event.canceled",
+		provider: "calendar",
+		description: "Triggers immediately when a calendar event is canceled",
+	},
+	{
+		type: "slack.message",
+		provider: "slack",
+		description:
+			"Triggers immediately after a new message is posted in Slack (includes new threads and replies)",
+	},
+	{
+		type: "slack.reaction.added",
+		provider: "slack",
+		description:
+			"Triggers immediately after a reaction is added to a message in Slack",
+	},
+	{
+		type: "slack.app.mention",
+		provider: "slack",
+		description:
+			"Triggers when the agent is mentioned in a Slack channel or direct message",
+	},
+	{
+		type: "googleDriveOauth.filesChanged",
+		provider: "googleDriveOauth",
+		description:
+			"Watches for file changes in a specific Google Drive folder (direct children only) or shared drive. The My Drive root is not supported. Fires on a schedule and provides change tokens for fetching the list of changes.",
+	},
+	{
+		type: "discord.interaction",
+		provider: "discord",
+		description:
+			"Triggers when a user invokes the /ai slash command in a configured Discord channel",
+	},
+] as const