@notionhq/custom-blocks 0.0.61 → 0.0.62

package/bin/notion-custom-blocks/build.js

@@ -0,0 +1,187 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { packDirToTarGz } from "./tar.js";
+export const BUILD_OUTPUT_SENTINEL = "<__notion_custom_block__>";
+export const BUILD_OUTPUT_SENTINEL_CLOSE = "</__notion_custom_block__>";
+const WORKER_ENTRY = "dist/index.js";
+/**
+ * Build every `_tag: "custom_block"` view declared by the worker.
+ *
+ * Imports the worker bundle (`<cwd>/dist/index.js`), reads its runtime manifest,
+ * and runs the command specified (default `npm run build`)
+ */
+export async function buildCustomBlocks(args) {
+    const projectRoot = args.cwd ?? process.cwd();
+    const entryPath = path.resolve(projectRoot, WORKER_ENTRY);
+    const outDir = path.resolve(args.out);
+    const blocks = await readCustomBlocks(entryPath);
+    if (blocks.length === 0) {
+        return { blocks: [] };
+    }
+    const built = [];
+    for (const block of blocks) {
+        const bundleDir = path.join(outDir, block.key);
+        buildCustomBlock({ block, projectRoot, bundleDir });
+        const { checksumCrc32 } = packDirToTarGz(bundleDir);
+        built.push({ key: block.key, checksumCrc32, bundleDir });
+    }
+    return { blocks: built };
+}
+/** Print the build output as the sentinel-wrapped single-line JSON contract. */
+export function printBuildOutput(output) {
+    process.stdout.write(`${BUILD_OUTPUT_SENTINEL}${JSON.stringify(output)}${BUILD_OUTPUT_SENTINEL_CLOSE}\n`);
+}
+async function readCustomBlocks(entryPath) {
+    const mod = await import(pathToFileURL(entryPath).href);
+    const worker = resolveWorker(mod);
+    const manifest = readProp(worker, "manifest");
+    const capabilities = readProp(manifest, "capabilities");
+    if (!Array.isArray(capabilities)) {
+        throw new Error(`worker manifest at ${entryPath} has no capabilities array`);
+    }
+    const blocks = [];
+    for (const capability of capabilities) {
+        const block = asCustomBlock(capability);
+        if (block) {
+            blocks.push(block);
+        }
+    }
+    return blocks;
+}
+function resolveWorker(mod) {
+    const top = readProp(mod, "default");
+    if (top === undefined) {
+        throw new Error("worker module has no default export");
+    }
+    const nested = readProp(top, "default");
+    return nested ?? top;
+}
+function readProp(value, key) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    return value[key];
+}
+function asCustomBlock(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const record = value;
+    if (record._tag !== "custom_block") {
+        return undefined;
+    }
+    if (typeof record.key !== "string") {
+        throw new Error("custom_block capability is missing a string key");
+    }
+    const config = record.config;
+    if (typeof config !== "object" || config === null) {
+        throw new Error(`custom_block "${record.key}" is missing config`);
+    }
+    const source = parseSource(record.key, config.source);
+    const dataSources = config.dataSources;
+    const manifest = config.manifest;
+    return {
+        key: record.key,
+        config: {
+            source,
+            ...(isStringRecord(dataSources) ? { dataSources } : {}),
+            manifest,
+        },
+    };
+}
+function parseSource(key, value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error(`custom_block "${key}" is missing a source`);
+    }
+    const source = value;
+    if (source.type === "project") {
+        if (typeof source.path !== "string") {
+            throw new Error(`custom_block "${key}" project source is missing a string path`);
+        }
+        return {
+            type: "project",
+            path: source.path,
+            ...(typeof source.command === "string"
+                ? { command: source.command }
+                : {}),
+            ...(typeof source.output === "string" ? { output: source.output } : {}),
+        };
+    }
+    if (source.type === "static") {
+        if (typeof source.path !== "string") {
+            throw new Error(`custom_block "${key}" static source is missing a string path`);
+        }
+        return { type: "static", path: source.path };
+    }
+    throw new Error(`custom_block "${key}" has an unsupported source type "${String(source.type)}" — this worker may need a newer @notionhq/workers`);
+}
+function isStringRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    return Object.values(value).every(v => typeof v === "string");
+}
+function buildCustomBlock(args) {
+    const { block, projectRoot, bundleDir } = args;
+    const sourceDir = resolveSourceDir(block.key, block.config.source, projectRoot);
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+    fs.mkdirSync(bundleDir, { recursive: true });
+    fs.cpSync(sourceDir, bundleDir, { recursive: true });
+}
+const DEFAULT_BUILD_COMMAND = "npm run build";
+const DEFAULT_OUTPUT_DIR = "dist";
+function resolveSourceDir(key, source, projectRoot) {
+    if (source.type === "static") {
+        const dir = path.resolve(projectRoot, source.path);
+        if (!fs.existsSync(dir)) {
+            throw new Error(`custom_block "${key}" static dir not found: ${dir}`);
+        }
+        return dir;
+    }
+    const projectDir = path.resolve(projectRoot, source.path);
+    if (!fs.existsSync(projectDir)) {
+        throw new Error(`custom_block "${key}" project dir not found: ${projectDir}`);
+    }
+    installProjectDeps(key, projectDir);
+    const command = source.command ?? DEFAULT_BUILD_COMMAND;
+    runCommand(key, command, projectDir);
+    const outputDir = path.resolve(projectDir, source.output ?? DEFAULT_OUTPUT_DIR);
+    if (!fs.existsSync(outputDir)) {
+        throw new Error(`custom_block "${key}" build command "${command}" produced no output at ${outputDir}`);
+    }
+    return outputDir;
+}
+/**
+ * Install a `project` source's own dependencies before building it. `npm ci`
+ * when a lockfile is present (faster + deterministic), else `npm install`. No-op
+ * when the project has no package.json.
+ */
+function installProjectDeps(key, projectDir) {
+    if (!fs.existsSync(path.join(projectDir, "package.json"))) {
+        return;
+    }
+    const hasLockfile = fs.existsSync(path.join(projectDir, "package-lock.json"));
+    runCommand(key, hasLockfile ? "npm ci" : "npm install", projectDir);
+}
+/**
+ * Run a shell command in `cwd`. The child's stdout/stderr are forwarded to our
+ * stderr so build/install logs never contaminate the sentinel-wrapped JSON
+ * contract this tool writes to stdout.
+ */
+function runCommand(key, command, cwd) {
+    const result = spawnSync(command, { cwd, shell: true, encoding: "utf8" });
+    if (result.stdout) {
+        process.stderr.write(result.stdout);
+    }
+    if (result.stderr) {
+        process.stderr.write(result.stderr);
+    }
+    if (result.error) {
+        throw new Error(`custom_block "${key}" build command "${command}" failed to start: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`custom_block "${key}" build command "${command}" exited with code ${String(result.status)}`);
+    }
+}

package/bin/notion-custom-blocks/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { buildCustomBlocks, printBuildOutput } from "./build.js";
+import { parseUploadsInput, uploadViews } from "./upload.js";
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case "build":
+            return runBuild(rest);
+        case "upload":
+            return runUpload(rest);
+        default:
+            printUsage();
+            return command === undefined ? 0 : 1;
+    }
+}
+async function runBuild(args) {
+    const flags = parseFlags(args);
+    const out = flags.out;
+    if (out === undefined) {
+        process.stderr.write("usage: notion-custom-blocks build --out <dir>\n");
+        return 1;
+    }
+    const output = await buildCustomBlocks({ out });
+    printBuildOutput(output);
+    return 0;
+}
+async function runUpload(args) {
+    const flags = parseFlags(args);
+    const raw = flags.uploads;
+    if (raw === undefined) {
+        process.stderr.write("usage: notion-custom-blocks upload --uploads '<json>'\n");
+        return 1;
+    }
+    const uploads = parseUploadsInput(raw);
+    const output = await uploadViews(uploads);
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    return 0;
+}
+function parseFlags(args) {
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === undefined || !arg.startsWith("--")) {
+            continue;
+        }
+        const name = arg.slice(2);
+        const value = args[i + 1];
+        if (value === undefined) {
+            continue;
+        }
+        flags[name] = value;
+        i++;
+    }
+    return flags;
+}
+function printUsage() {
+    process.stderr.write("Invalid command. See notion-custom-blocks source.");
+}
+main(process.argv.slice(2))
+    .then(code => {
+    process.exitCode = code;
+})
+    .catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/bin/notion-custom-blocks/tar.js

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as zlib from "node:zlib";
+/**
+ * Deterministic gzipped-tarball packing for custom-block bundles, shared by the
+ * `build` and `upload` phases.
+ */
+const BLOCK_SIZE = 512;
+/**
+ * Pack a directory into a deterministic gzipped tarball and return both the
+ * bytes and their base64 big-endian crc32 checksum (the form
+ * `CreateCustomBlockDeploy` signs into the presigned PUT URL).
+ */
+export function packDirToTarGz(dir) {
+    const entries = collectFiles(dir);
+    const tar = writeUstarArchive(entries);
+    const tarGz = zlib.gzipSync(tar, {
+        level: zlib.constants.Z_BEST_COMPRESSION,
+    });
+    // Zero the gzip header's MTIME field (bytes 4..7) so repeated packs of the
+    // same input are byte-identical. The build phase's crc32 must match the
+    // bytes the upload phase PUTs, and gzip otherwise stamps the current time.
+    if (tarGz.length >= 8) {
+        tarGz.writeUInt32LE(0, 4);
+    }
+    return { tarGz, checksumCrc32: crc32Base64(tarGz) };
+}
+/** Base64-encoded big-endian crc32, matching the server's `CRC32_BASE64_REGEX`. */
+export function crc32Base64(data) {
+    const checksum = zlib.crc32(data) >>> 0;
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(checksum);
+    return buf.toString("base64");
+}
+/** Recursively collect regular files under `dir`, sorted by archive path. */
+function collectFiles(dir) {
+    const entries = [];
+    function walk(absDir, relDir) {
+        const dirents = fs.readdirSync(absDir, { withFileTypes: true });
+        for (const dirent of dirents) {
+            const abs = path.join(absDir, dirent.name);
+            const rel = relDir === "" ? dirent.name : `${relDir}/${dirent.name}`;
+            if (dirent.isDirectory()) {
+                walk(abs, rel);
+            }
+            else if (dirent.isFile()) {
+                entries.push({ name: rel, contents: fs.readFileSync(abs) });
+            }
+        }
+    }
+    walk(dir, "");
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return entries;
+}
+/** Serialize entries as a minimal POSIX ustar archive. */
+function writeUstarArchive(entries) {
+    const chunks = [];
+    for (const entry of entries) {
+        chunks.push(writeUstarHeader(entry.name, entry.contents.length));
+        chunks.push(entry.contents);
+        const remainder = entry.contents.length % BLOCK_SIZE;
+        if (remainder !== 0) {
+            chunks.push(Buffer.alloc(BLOCK_SIZE - remainder));
+        }
+    }
+    // Two zero blocks mark end-of-archive.
+    chunks.push(Buffer.alloc(BLOCK_SIZE * 2));
+    return Buffer.concat(chunks);
+}
+function writeUstarHeader(name, size) {
+    const header = Buffer.alloc(BLOCK_SIZE);
+    const nameBytes = Buffer.from(name, "utf8");
+    if (nameBytes.length > 100) {
+        // ustar splits long paths into name/prefix; keep bundles simple by
+        // requiring short paths rather than emitting a GNU/PAX extension.
+        throw new Error(`tar entry path too long (max 100 bytes): ${name}`);
+    }
+    nameBytes.copy(header, 0);
+    writeOctal(header, 100, 8, 0o644); // mode
+    writeOctal(header, 108, 8, 0); // uid
+    writeOctal(header, 116, 8, 0); // gid
+    writeOctal(header, 124, 12, size); // size
+    writeOctal(header, 136, 12, 0); // mtime
+    header.write("0", 156, 1, "ascii"); // typeflag: regular file
+    header.write("ustar\0", 257, 6, "ascii"); // magic
+    header.write("00", 263, 2, "ascii"); // version
+    // Checksum field: spaces during computation, then octal value.
+    header.fill(" ", 148, 156);
+    let checksum = 0;
+    for (let i = 0; i < BLOCK_SIZE; i++) {
+        checksum += header[i] ?? 0;
+    }
+    header.write(checksum.toString(8).padStart(6, "0"), 148, 6, "ascii");
+    header.write("\0 ", 154, 2, "ascii");
+    return header;
+}
+function writeOctal(header, offset, length, value) {
+    // Numeric fields are octal ASCII, null-terminated, right-justified.
+    const str = value.toString(8).padStart(length - 1, "0");
+    header.write(str, offset, length - 1, "ascii");
+    header.write("\0", offset + length - 1, 1, "ascii");
+}

package/bin/notion-custom-blocks/upload.js

@@ -0,0 +1,60 @@
+import { packDirToTarGz } from "./tar.js";
+const DEFAULT_DEPS = { fetch: globalThis.fetch };
+export async function uploadViews(uploads, deps = DEFAULT_DEPS) {
+    const uploaded = {};
+    for (const [key, target] of Object.entries(uploads)) {
+        const { tarGz, checksumCrc32 } = packDirToTarGz(target.bundleDir);
+        const response = await deps.fetch(target.uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/gzip",
+                "x-amz-checksum-crc32": checksumCrc32,
+            },
+            body: new Uint8Array(tarGz),
+        });
+        if (!response.ok) {
+            const text = await safeReadText(response);
+            throw new Error(`upload failed for block "${key}": ${response.status} ${response.statusText}${text ? `\n${text}` : ""}`);
+        }
+        uploaded[key] = true;
+    }
+    return { uploaded };
+}
+export function parseUploadsInput(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`--uploads is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("--uploads must be a JSON object of { key: target }");
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value !== "object" || value === null) {
+            throw new Error(`--uploads["${key}"] must be an object`);
+        }
+        const record = value;
+        if (typeof record.uploadUrl !== "string") {
+            throw new Error(`--uploads["${key}"].uploadUrl must be a string`);
+        }
+        if (typeof record.bundleDir !== "string") {
+            throw new Error(`--uploads["${key}"].bundleDir must be a string`);
+        }
+        result[key] = {
+            uploadUrl: record.uploadUrl,
+            bundleDir: record.bundleDir,
+        };
+    }
+    return result;
+}
+async function safeReadText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/version.js

@@ -4,4 +4,4 @@
  *
  * WARNING: Generated during SDK publish. Do not edit in the published package.
  */
-export const NCBLOCK_SDK_VERSION = "0.0.61"
+export const NCBLOCK_SDK_VERSION = "0.0.62"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@notionhq/custom-blocks",
-	"version": "0.0.61",
+	"version": "0.0.62",
 	"license": "MIT",
 	"type": "module",
 	"publishConfig": {
@@ -32,7 +32,8 @@
 		}
 	},
 	"bin": {
-		"ncblock": "./bin/cli/cli.js"
+		"ncblock": "./bin/cli/cli.js",
+		"notion-custom-blocks": "./bin/notion-custom-blocks/cli.js"
 	},
 	"scripts": {
 		"test": "vitest run --environment jsdom",