@notionhq/apps 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Notion Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# Apps SDK
+
+## Development
+
+1. Install [mise](https://mise.jdx.dev/getting-started.html)
+2. Run `mise install`
+3. Run `mise run install`
+4. Run `mise run check && mise run test`
+
+The SDK requires Node 26 or newer and supports workflow capabilities only:
+
+```ts
+import { triggers } from "@notionhq/apps/triggers";
+import { createWorkflow } from "@notionhq/apps/workflow";
+```
+
+## Publishing New Versions
+
+Increment the package version and create a new Git tag:
+
+```shell
+# This also creates a Git tag.
+mise run version:apps patch
+```
+
+Then, push the commit and tag:
+
+```shell
+git push origin main --follow-tags
+```

package/dist/cli/build.d.ts

@@ -0,0 +1,13 @@
+import type { AppManifest } from "../manifest.js";
+export type BuildResult = {
+    manifest: AppManifest;
+    bundlePath: string;
+    manifestPath: string;
+};
+/**
+ * Build an app project: discover capability files by convention, generate
+ * the entry module, bundle it into a single `dist/worker.js`, and emit
+ * `dist/manifest.json` describing every capability.
+ */
+export declare function buildApp(projectRoot: string): Promise<BuildResult>;
+//# sourceMappingURL=build.d.ts.map

package/dist/cli/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD,MAAM,MAAM,WAAW,GAAG;IACzB,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAmCxE"}

package/dist/cli/build.js

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { rolldown } from "rolldown";
+import { generateEntry } from "./codegen.js";
+import { discoverCapabilities } from "./discover.js";
+import { extractManifest } from "./emit-manifest.js";
+async function buildApp(projectRoot) {
+  const capabilities = await discoverCapabilities(projectRoot);
+  if (capabilities.length === 0) {
+    throw new Error(
+      `No capabilities found in ${projectRoot}. Add a workflow file under src/workflows/<name>.ts that default-exports createWorkflow(...).`
+    );
+  }
+  const entryPath = path.join(projectRoot, ".notion", "entry.ts");
+  await fs.promises.mkdir(path.dirname(entryPath), { recursive: true });
+  await fs.promises.writeFile(entryPath, generateEntry(capabilities));
+  const bundlePath = path.join(projectRoot, "dist", "worker.js");
+  const bundle = await rolldown({
+    input: entryPath,
+    platform: "node",
+    external: (id) => !id.startsWith(".") && !path.isAbsolute(id)
+  });
+  try {
+    await bundle.write({ format: "esm", file: bundlePath });
+  } finally {
+    await bundle.close();
+  }
+  const manifest = await extractManifest(bundlePath, capabilities);
+  const manifestPath = path.join(projectRoot, "dist", "manifest.json");
+  await fs.promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, "	")}
+`);
+  return { manifest, bundlePath, manifestPath };
+}
+export {
+  buildApp
+};

package/dist/cli/build.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build.test.d.ts.map

package/dist/cli/build.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.test.d.ts","sourceRoot":"","sources":["../../src/cli/build.test.ts"],"names":[],"mappings":""}

package/dist/cli/codegen.d.ts

@@ -0,0 +1,10 @@
+import type { DiscoveredCapability } from "./discover.js";
+/**
+ * Generate the app entry module for a set of discovered capabilities.
+ *
+ * The module uses only static imports so that the bundler can bundle the
+ * whole app into a single file. It is written to `.notion/entry.ts` in
+ * the app project, so imports are relative to that location.
+ */
+export declare function generateEntry(capabilities: readonly DiscoveredCapability[]): string;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/cli/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/cli/codegen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,MAAM,CAyCnF"}

package/dist/cli/codegen.js

@@ -0,0 +1,41 @@
+function generateEntry(capabilities) {
+  const imports = [];
+  const registryEntries = /* @__PURE__ */ new Map();
+  capabilities.forEach((capability, index) => {
+    const binding = `capability_${index}`;
+    imports.push(`import ${binding} from ${JSON.stringify(`../${capability.sourcePath}`)};`);
+    const entries = registryEntries.get(capability.type) ?? [];
+    entries.push(`		${JSON.stringify(capability.key)}: ${binding},`);
+    registryEntries.set(capability.type, entries);
+  });
+  const registry = Array.from(registryEntries.entries()).map(([type, entries]) => `	${JSON.stringify(type)}: {
+${entries.join("\n")}
+	},`).join("\n");
+  return `// Generated by \`notion-apps build\`. Do not edit.
+${imports.join("\n")}
+
+type Handler = (context?: unknown, options?: { concreteOutput?: true }) => Promise<unknown>;
+
+export const capabilities: Record<string, Record<string, { handler: Handler }>> = {
+${registry}
+};
+
+export async function run(
+	type: string,
+	key: string,
+	context?: unknown,
+	options?: { concreteOutput?: true },
+): Promise<unknown> {
+	const capability = capabilities[type]?.[key];
+
+	if (!capability) {
+		throw new Error(\`Capability "\${type}/\${key}" not found\`);
+	}
+
+	return capability.handler(context, options);
+}
+`;
+}
+export {
+  generateEntry
+};

package/dist/cli/codegen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codegen.test.d.ts.map

package/dist/cli/codegen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.test.d.ts","sourceRoot":"","sources":["../../src/cli/codegen.test.ts"],"names":[],"mappings":""}

package/dist/cli/discover.d.ts

@@ -0,0 +1,32 @@
+import type { CapabilityType } from "../manifest.js";
+/**
+ * A capability type the build tool knows how to discover: which directory
+ * under `src/` its files live in, and the `_tag` its default exports must
+ * carry. This SDK intentionally registers workflows only.
+ */
+export type CapabilityTypeDefinition = {
+    type: CapabilityType;
+    directory: string;
+    tag: string;
+};
+export declare const CAPABILITY_TYPES: readonly CapabilityTypeDefinition[];
+/**
+ * A capability file found during discovery. The key is the file's basename;
+ * combined with the type it forms the capability's identity (`workflow/onPageCreated`).
+ */
+export type DiscoveredCapability = {
+    type: CapabilityType;
+    tag: string;
+    key: string;
+    /** Path to the source file, relative to the project root. */
+    sourcePath: string;
+};
+/**
+ * Discover capability files by convention: every `.ts` file directly under
+ * `src/<directory>/` for each registered capability type. Subdirectories are
+ * not searched — they hold plain modules, not capabilities.
+ *
+ * Only workflow files directly under `src/workflows/` are discovered.
+ */
+export declare function discoverCapabilities(projectRoot: string): Promise<DiscoveredCapability[]>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/cli/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/cli/discover.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACtC,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,SAAS,wBAAwB,EAE/D,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAiC/F"}

package/dist/cli/discover.js

@@ -0,0 +1,37 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const CAPABILITY_TYPES = [
+  { type: "workflow", directory: "workflows", tag: "workflow" }
+];
+async function discoverCapabilities(projectRoot) {
+  const discovered = [];
+  for (const definition of CAPABILITY_TYPES) {
+    const directory = path.join(projectRoot, "src", definition.directory);
+    let entries;
+    try {
+      entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) {
+        continue;
+      }
+      discovered.push({
+        type: definition.type,
+        tag: definition.tag,
+        key: entry.name.slice(0, -".ts".length),
+        sourcePath: path.join("src", definition.directory, entry.name)
+      });
+    }
+  }
+  return discovered;
+}
+export {
+  CAPABILITY_TYPES,
+  discoverCapabilities
+};

package/dist/cli/discover.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=discover.test.d.ts.map

package/dist/cli/discover.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.test.d.ts","sourceRoot":"","sources":["../../src/cli/discover.test.ts"],"names":[],"mappings":""}

package/dist/cli/emit-manifest.d.ts

@@ -0,0 +1,10 @@
+import type { AppManifest } from "../manifest.js";
+import type { DiscoveredCapability } from "./discover.js";
+/** Extract the workflow-only app manifest from a built bundle. */
+export declare function extractManifest(bundlePath: string, capabilities: readonly DiscoveredCapability[]): Promise<AppManifest>;
+/**
+ * Throw if `value` contains anything `JSON.stringify` would silently drop or
+ * rewrite, so invalid workflow configuration fails during the build.
+ */
+export declare function assertJsonSafe(value: unknown, path: string): void;
+//# sourceMappingURL=emit-manifest.d.ts.map

package/dist/cli/emit-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-manifest.d.ts","sourceRoot":"","sources":["../../src/cli/emit-manifest.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAgD1D,kEAAkE;AAClE,wBAAsB,eAAe,CACpC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC3C,OAAO,CAAC,WAAW,CAAC,CAmCtB;AAgDD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA4CjE"}

package/dist/cli/emit-manifest.js

@@ -0,0 +1,131 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { Ajv } from "ajv";
+const SDK_VERSION = (() => {
+  const require2 = createRequire(import.meta.url);
+  const packageJson = require2("../../package.json");
+  if (typeof packageJson !== "object" || packageJson === null || !("version" in packageJson) || typeof packageJson.version !== "string") {
+    throw new Error("Failed to read SDK version from package.json");
+  }
+  return packageJson.version;
+})();
+const MANIFEST_SCHEMA = {
+  type: "object",
+  properties: {
+    sdkVersion: { type: "string" },
+    databases: { type: "array", maxItems: 0 },
+    xldbs: { type: "array", maxItems: 0 },
+    pacers: { type: "array", maxItems: 0 },
+    capabilities: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string", const: "workflow" },
+          key: { type: "string" },
+          config: {}
+        },
+        required: ["type", "key", "config"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["sdkVersion", "databases", "xldbs", "pacers", "capabilities"],
+  additionalProperties: false
+};
+async function extractManifest(bundlePath, capabilities) {
+  const bundle = await importBundle(bundlePath);
+  const capabilityRegistry = getCapabilityRegistry(bundle);
+  const capabilityEntries = capabilities.map((capability) => {
+    const value = capabilityRegistry.workflow?.[capability.key];
+    const workflow = asWorkflow(value);
+    if (!workflow) {
+      throw new Error(
+        `${capability.sourcePath}: default export is not a workflow \u2014 files under src/workflows/ must default-export createWorkflow(...)`
+      );
+    }
+    assertJsonSafe(workflow.config, `${capability.sourcePath} config`);
+    return { type: "workflow", key: capability.key, config: workflow.config };
+  });
+  const manifest = JSON.parse(
+    JSON.stringify({
+      sdkVersion: SDK_VERSION,
+      databases: [],
+      xldbs: [],
+      pacers: [],
+      capabilities: capabilityEntries
+    })
+  );
+  const ajv = new Ajv();
+  if (!ajv.validate(MANIFEST_SCHEMA, manifest)) {
+    throw new Error(`Generated manifest is invalid: ${ajv.errorsText(ajv.errors)}`);
+  }
+  return manifest;
+}
+let importNonce = 0;
+async function importBundle(bundlePath) {
+  try {
+    return await import(`${pathToFileURL(bundlePath).href}?import=${importNonce++}`);
+  } catch (error) {
+    throw new Error(
+      `Failed to import built app bundle. Workflow modules must be importable without secrets or network access \u2014 check for top-level code that throws.
+Caused by: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getCapabilityRegistry(bundle) {
+  if (typeof bundle !== "object" || bundle === null || !("capabilities" in bundle) || typeof bundle.capabilities !== "object" || bundle.capabilities === null) {
+    throw new Error("Built app bundle does not export a capability registry");
+  }
+  return bundle.capabilities;
+}
+function asWorkflow(value) {
+  if (typeof value === "object" && value !== null && "_tag" in value && value._tag === "workflow" && "config" in value && typeof value.config === "object" && value.config !== null) {
+    return value;
+  }
+  return void 0;
+}
+function assertJsonSafe(value, path) {
+  const reject = (reason) => {
+    throw new Error(`${path}: not JSON-serializable (${reason})`);
+  };
+  switch (typeof value) {
+    case "function":
+      reject("function");
+      break;
+    case "symbol":
+      reject("symbol");
+      break;
+    case "bigint":
+      reject("bigint");
+      break;
+    case "number":
+      if (!Number.isFinite(value)) reject(String(value));
+      return;
+    case "string":
+    case "boolean":
+    case "undefined":
+      return;
+  }
+  if (value === null) return;
+  if (Array.isArray(value)) {
+    value.forEach((element, index) => {
+      if (element === void 0) reject(`undefined at [${index}]`);
+      assertJsonSafe(element, `${path}[${index}]`);
+    });
+    return;
+  }
+  const object = value;
+  const prototype = Object.getPrototypeOf(object);
+  if (prototype !== null && prototype !== Object.prototype) {
+    reject(object.constructor?.name ?? "non-plain object");
+  }
+  for (const [key, property] of Object.entries(object)) {
+    if (property === void 0) continue;
+    assertJsonSafe(property, `${path}.${key}`);
+  }
+}
+export {
+  assertJsonSafe,
+  extractManifest
+};

package/dist/cli/emit-manifest.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=emit-manifest.test.d.ts.map

package/dist/cli/emit-manifest.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-manifest.test.d.ts","sourceRoot":"","sources":["../../src/cli/emit-manifest.test.ts"],"names":[],"mappings":""}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import * as path from "node:path";
+import { buildApp } from "./build.js";
+const USAGE = `Usage: notion-apps <command>
+
+Commands:
+  build    Build the app in the current directory
+`;
+async function main() {
+  const command = process.argv[2];
+  switch (command) {
+    case "build": {
+      const projectRoot = process.cwd();
+      const { manifest, bundlePath, manifestPath } = await buildApp(projectRoot);
+      const count = manifest.capabilities.length;
+      console.log(
+        `Built ${path.relative(projectRoot, bundlePath)} and ${path.relative(projectRoot, manifestPath)} (${count} ${count === 1 ? "capability" : "capabilities"})`
+      );
+      break;
+    }
+    case void 0:
+    case "help":
+    case "--help":
+      console.log(USAGE);
+      break;
+    default:
+      console.error(`Unknown command: ${command}
+
+${USAGE}`);
+      process.exitCode = 1;
+  }
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/dist/context.d.ts

@@ -0,0 +1,7 @@
+import { Client } from "@notionhq/client";
+export type CapabilityContext = {
+    /** Notion API SDK client for this execution. */
+    notion: Client;
+};
+export declare function createCapabilityContext(): CapabilityContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,MAAM,MAAM,iBAAiB,GAAG;IAC/B,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AA2BF,wBAAgB,uBAAuB,IAAI,iBAAiB,CAe3D"}

package/dist/context.js

@@ -0,0 +1,30 @@
+import { Client } from "@notionhq/client";
+const FIX_STEPS = "\n\nTo fix this:\n1. Create a personal access token at https://app.notion.com/developers/tokens\n2. Add NOTION_API_TOKEN=<your-token> to your .env file\n3. For deployed apps, run: ntn apps env push";
+function missingTokenMessage() {
+  return "NOTION_API_TOKEN is not set. context.notion requires an API token to make requests in workflow capabilities to Notion." + FIX_STEPS;
+}
+function createUnauthenticatedNotionProxy() {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "then" || typeof prop === "symbol") {
+        return void 0;
+      }
+      throw new Error(missingTokenMessage());
+    }
+  });
+}
+function createCapabilityContext() {
+  const options = {};
+  if (process.env.NOTION_API_BASE_URL) {
+    options.baseUrl = process.env.NOTION_API_BASE_URL;
+  }
+  if (!process.env.NOTION_API_TOKEN) {
+    return { notion: createUnauthenticatedNotionProxy() };
+  }
+  options.auth = process.env.NOTION_API_TOKEN;
+  const notion = new Client(options);
+  return { notion };
+}
+export {
+  createCapabilityContext
+};

package/dist/error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An error that occurred during the execution of an app capability.
+ */
+export declare class ExecutionError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACxC,SAAkB,KAAK,EAAE,OAAO,CAAC;gBAErB,KAAK,EAAE,OAAO;CAK1B"}

package/dist/error.js

@@ -0,0 +1,11 @@
+class ExecutionError extends Error {
+  cause;
+  constructor(cause) {
+    super(`Error during app execution: ${cause}`);
+    this.name = "ExecutionError";
+    this.cause = cause;
+  }
+}
+export {
+  ExecutionError
+};

package/dist/manifest.d.ts

@@ -0,0 +1,25 @@
+/** The only capability type supported by this SDK. */
+export type CapabilityType = "workflow";
+/**
+ * One capability in the manifest: its type, its key (derived from its
+ * filename), and its handler-free configuration.
+ */
+export type CapabilityManifestEntry = {
+    type: CapabilityType;
+    key: string;
+    config: unknown;
+};
+/**
+ * The full app manifest, emitted by `notion-apps build` as
+ * `dist/manifest.json` and read by the platform at deploy time. This is a
+ * complete, static description of the app.
+ */
+export type AppManifest = {
+    sdkVersion: string;
+    /** Reserved platform fields; workflow-only apps always emit empty arrays. */
+    databases: never[];
+    xldbs: never[];
+    pacers: never[];
+    capabilities: CapabilityManifestEntry[];
+};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,SAAS,EAAE,KAAK,EAAE,CAAC;IACnB,KAAK,EAAE,KAAK,EAAE,CAAC;IACf,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,YAAY,EAAE,uBAAuB,EAAE,CAAC;CACxC,CAAC"}

package/dist/output.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Writes a notion_output envelope to stdout using the shared wire format.
+ * The platform runner scans a run's log stream for this envelope to
+ * recover the capability's result.
+ */
+export declare function writeOutput(value: unknown): void;
+//# sourceMappingURL=output.d.ts.map

package/dist/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEhD"}

package/dist/output.js

@@ -0,0 +1,8 @@
+function writeOutput(value) {
+  process.stdout.write(`
+<__notion_output__>${JSON.stringify(value)}</__notion_output__>
+`);
+}
+export {
+  writeOutput
+};

package/dist/runtime-metadata.d.ts

@@ -0,0 +1,9 @@
+export type RunMetadata = {
+    workspaceId: string;
+    workerId: string;
+    runGroupId: string;
+    runId: string;
+    capabilityType: "workflow";
+    attemptNumber: number;
+};
+//# sourceMappingURL=runtime-metadata.d.ts.map

package/dist/runtime-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-metadata.d.ts","sourceRoot":"","sources":["../src/runtime-metadata.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,UAAU,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACtB,CAAC"}

package/dist/runtime-metadata.js

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { Ajv } from "ajv";
+const runMetadataSchema = {
+  type: "object",
+  properties: {
+    workspaceId: { type: "string" },
+    workerId: { type: "string" },
+    runGroupId: { type: "string" },
+    runId: { type: "string" },
+    capabilityType: { type: "string", const: "workflow" },
+    attemptNumber: { type: "number" }
+  },
+  required: ["workspaceId", "workerId", "runGroupId", "runId", "capabilityType", "attemptNumber"],
+  additionalProperties: false
+};
+const ajv = new Ajv();
+const validateRunMetadata = ajv.compile(runMetadataSchema);
+function readRunMetadata() {
+  const runMetadataPath = process.env.NOTION_RUN_METADATA_PATH;
+  if (runMetadataPath === void 0) {
+    throw new Error("Workflow run metadata path is not configured");
+  }
+  const parsed = JSON.parse(readFileSync(runMetadataPath, "utf8"));
+  if (!validateRunMetadata(parsed)) {
+    throw new Error(
+      `Invalid workflow run metadata: ${ajv.errorsText(validateRunMetadata.errors)}`
+    );
+  }
+  return parsed;
+}
+export {
+  readRunMetadata
+};

package/dist/runtime-metadata.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime-metadata.test.d.ts.map

package/dist/runtime-metadata.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-metadata.test.d.ts","sourceRoot":"","sources":["../src/runtime-metadata.test.ts"],"names":[],"mappings":""}