@reasonlayer/sdk 0.0.1-rc.3

package/node_modules/@reasonlayer/protocol/dist/ir.d.ts

@@ -0,0 +1,252 @@
+/**
+ * The IR contract (spec §5). The five step kinds are the complete V2 language —
+ * no legacy kinds, no version negotiation. Both the SDK compiler and the engine import these
+ * types, so drift is a compile error.
+ */
+/** JSON Schema draft-07, output mode (spec §4.4). */
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Cross-step data flow (spec §4.2). `mapItem` is only valid inside a map
+ * child's selectors; the compiler enforces scope.
+ */
+export type SelectorIR = {
+    kind: "input";
+    path: string[];
+} | {
+    kind: "step";
+    stepId: string;
+    path: string[];
+} | {
+    kind: "variable";
+    name: string;
+    path: string[];
+} | {
+    kind: "literal";
+    value: unknown;
+} | {
+    kind: "object";
+    fields: Record<string, SelectorIR>;
+} | {
+    kind: "array";
+    items: SelectorIR[];
+} | {
+    kind: "mapItem";
+    path: string[];
+};
+export interface RetryPolicyIR {
+    maxAttempts: number;
+    backoffMs?: number;
+}
+export interface SecretRefIR {
+    kind: "secret";
+    name: string;
+}
+export interface VariableIR {
+    name: string;
+    schemaJson: JsonSchema;
+    defaultJson: unknown;
+    description?: string;
+}
+export declare const VARIABLE_NAME_PATTERN: RegExp;
+export interface DeviceRefIR {
+    kind: "device";
+    handle: string;
+}
+export declare const STEP_ID_PATTERN: RegExp;
+export interface LocalMcpServerIR {
+    kind: "command";
+    command: string;
+    /**
+     * Command MCP servers are currently expected to expose a streamable HTTP
+     * endpoint on the assigned PORT. Stdio commands need a bridge before they
+     * can be run by the production supervisor.
+     */
+    transport: "http";
+    env?: Record<string, SecretRefIR>;
+}
+export interface RemoteMcpServerIR {
+    kind: "url";
+    url: string;
+    headers?: Record<string, SecretRefIR>;
+}
+export type McpServerIR = LocalMcpServerIR | RemoteMcpServerIR;
+export interface EnvironmentFileIR {
+    /** Absolute path inside the sandbox template/rootfs. */
+    path: string;
+    /** sha256 of contentBase64 decoded bytes. */
+    sha256: string;
+    /** Small file contents captured by the SDK build. */
+    contentBase64: string;
+}
+export interface EnvironmentIR {
+    /** sha256 over the canonical declaration JSON, excluding this field. */
+    envHash: string;
+    npm?: string[];
+    pip?: string[];
+    apt?: string[];
+    /** Extra executable names to verify, e.g. apt package ripgrep -> binary rg. */
+    binaries?: string[];
+    files?: EnvironmentFileIR[];
+    setup?: string[];
+    mcp?: Record<string, McpServerIR>;
+}
+export type EnvironmentStatusKind = "building" | "ready" | "failed";
+export interface EnvironmentMcpToolInventory {
+    tools: string[];
+    mode: "fake" | "runtime-deferred" | "verified";
+    note?: string;
+}
+export interface EnvironmentProvenance {
+    mode: "fake" | "e2b";
+    checkedAt: number;
+    declaredCliChecks: string[];
+    cliChecks?: Record<string, {
+        path: string;
+        exitCode: number;
+    }>;
+    buildInfo?: unknown;
+    mcpTools: Record<string, EnvironmentMcpToolInventory>;
+}
+export interface EnvironmentStatus {
+    envHash: string;
+    status: EnvironmentStatusKind;
+    templateAlias?: string;
+    error?: string;
+    provenance?: EnvironmentProvenance;
+}
+export type EnvironmentDeclaration = Omit<EnvironmentIR, "envHash">;
+export declare function stableJson(value: unknown): string;
+export declare function environmentDeclaration(environment: EnvironmentIR): EnvironmentDeclaration;
+export declare function canonicalEnvironmentDeclarationJson(environment: EnvironmentIR): string;
+export declare function mcpUrlEnvName(name: string): string;
+export declare function shellQuote(value: string): string;
+export interface ParsedNpmPackage {
+    packageName: string;
+    version: string;
+}
+export interface ParsedPipPackage {
+    packageName: string;
+    version: string;
+}
+export declare function parseExactNpmPackage(spec: string): ParsedNpmPackage | null;
+export declare function parseExactPipPackage(spec: string): ParsedPipPackage | null;
+export declare function executableNameFromPackageName(packageName: string): string;
+export declare function executableNameFromNpmSpec(spec: string): string;
+export declare function executableNameFromPipSpec(spec: string): string;
+export declare function firstCommandToken(command: string): string;
+export declare function declaredEnvironmentExecutables(environment: EnvironmentIR): string[];
+/** Execution host shape (spec §4.1), independent of the current provider adapter. */
+export type HostIR = {
+    kind: "cloud";
+} | {
+    kind: "device";
+    handle: string;
+};
+export type ReviewViewIR = {
+    kind: "json";
+} | {
+    kind: "builtin";
+    name: string;
+} | {
+    kind: "custom";
+    moduleRef: string;
+    exportName: string;
+};
+export interface CodeStepIR {
+    kind: "code";
+    id: string;
+    input: SelectorIR;
+    outputSchemaJson: JsonSchema;
+    moduleRef: string;
+    exportName: string;
+    host: HostIR;
+    browserProfile?: string;
+    timeoutMs?: number;
+    retries?: RetryPolicyIR;
+    secrets?: string[];
+    environment?: EnvironmentIR;
+}
+export interface AgentStepIR {
+    kind: "agent";
+    id: string;
+    input: SelectorIR;
+    outputSchemaJson: JsonSchema;
+    framework: "flue";
+    /** Canonical managed integration action ids injected as Flue tools. */
+    catalogTools: string[];
+    moduleRef: string;
+    exportName: string;
+    host: HostIR;
+    browserProfile?: string;
+    timeoutMs?: number;
+    retries?: RetryPolicyIR;
+    secrets?: string[];
+    environment?: EnvironmentIR;
+}
+export interface ReviewStepIR {
+    kind: "review";
+    id: string;
+    input: SelectorIR;
+    outputSchemaJson: JsonSchema;
+    view: ReviewViewIR;
+    deadlineMs?: number;
+}
+/** A managed catalog action. Provider and connection details never enter workflow IR. */
+export interface ActionStepIR {
+    kind: "action";
+    id: string;
+    actionId: string;
+    actionVersion: string;
+    input: SelectorIR;
+    inputSchemaJson: JsonSchema;
+    outputSchemaJson: JsonSchema;
+    timeoutMs?: number;
+    retries?: RetryPolicyIR;
+}
+export interface TriggerIR {
+    kind: "schedule";
+    name: string;
+    cron: string;
+    timezone: string;
+}
+/** The map child is itself a code/agent/review step; its selectors may use `mapItem`. */
+export type MapChildStepIR = CodeStepIR | AgentStepIR | ReviewStepIR;
+export interface MapStepIR {
+    kind: "map";
+    id: string;
+    /** The list to fan out over. */
+    over: SelectorIR;
+    /** Per-item identity for dedupe + resume; evaluated against the item (mapItem scope), must yield a string. */
+    key: SelectorIR;
+    step: MapChildStepIR;
+    concurrency?: number;
+    retries?: RetryPolicyIR;
+}
+export type StepIR = CodeStepIR | AgentStepIR | ReviewStepIR | ActionStepIR | MapStepIR;
+export interface WorkflowIR {
+    schemaVersion: 1;
+    id: string;
+    /** Authoring metadata surfaced in the console. */
+    description?: string;
+    /** Org-side placement handles declared with device(...). */
+    devices?: DeviceRefIR[];
+    /** Org-side vault handles declared with secret(...). */
+    secrets?: SecretRefIR[];
+    /** Typed data-plane values resolved and snapshotted when a run starts. */
+    variables?: VariableIR[];
+    /** Named declarations reconciled by (workflow, name) when a version publishes. */
+    triggers?: TriggerIR[];
+    inputSchemaJson: JsonSchema;
+    outputSchemaJson: JsonSchema;
+    steps: Record<string, StepIR>;
+    output: SelectorIR;
+}
+/** Map children share one bundle entrypoint per map step. */
+export declare function mapChildId(mapId: string): string;
+/** Managed placement rule (spec §4.1): all cloud steps run through the E2B claim path. */
+export declare function isCloudHostedStep(step: {
+    kind: string;
+    host?: HostIR;
+}): boolean;
+export declare function executableStepEnvironment(step: CodeStepIR | AgentStepIR | MapChildStepIR): EnvironmentIR | undefined;
+export declare function collectWorkflowEnvironments(ir: WorkflowIR): EnvironmentIR[];

package/node_modules/@reasonlayer/protocol/dist/ir.js

@@ -0,0 +1,116 @@
+/**
+ * The IR contract (spec §5). The five step kinds are the complete V2 language —
+ * no legacy kinds, no version negotiation. Both the SDK compiler and the engine import these
+ * types, so drift is a compile error.
+ */
+export const VARIABLE_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+export const STEP_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+export function stableJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    const entries = Object.entries(value)
+        .filter(([, nested]) => nested !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableJson(nested)}`).join(",")}}`;
+}
+export function environmentDeclaration(environment) {
+    const { envHash: _envHash, ...declaration } = environment;
+    return declaration;
+}
+export function canonicalEnvironmentDeclarationJson(environment) {
+    return stableJson(environmentDeclaration(environment));
+}
+export function mcpUrlEnvName(name) {
+    return `RL_MCP_${name.replace(/[^a-zA-Z0-9_]/g, "_").toUpperCase()}_URL`;
+}
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function parseExactNpmPackage(spec) {
+    const versionAt = spec.lastIndexOf("@");
+    if (versionAt <= 0)
+        return null;
+    const packageName = spec.slice(0, versionAt);
+    const version = spec.slice(versionAt + 1);
+    if (!packageName || !version || version === "latest")
+        return null;
+    if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+        return null;
+    return { packageName, version };
+}
+export function parseExactPipPackage(spec) {
+    const markerIndex = spec.indexOf("==");
+    if (markerIndex <= 0)
+        return null;
+    const packageName = spec.slice(0, markerIndex);
+    const version = spec.slice(markerIndex + 2);
+    if (!packageName || !/^[0-9][0-9A-Za-z.!+_-]*$/.test(version) || version.includes("*")) {
+        return null;
+    }
+    return { packageName, version };
+}
+export function executableNameFromPackageName(packageName) {
+    return packageName.split("/").pop() ?? packageName;
+}
+export function executableNameFromNpmSpec(spec) {
+    return executableNameFromPackageName(parseExactNpmPackage(spec)?.packageName ?? spec);
+}
+export function executableNameFromPipSpec(spec) {
+    return executableNameFromPackageName(parseExactPipPackage(spec)?.packageName ?? spec);
+}
+export function firstCommandToken(command) {
+    return command.trim().split(/\s+/)[0] ?? command;
+}
+export function declaredEnvironmentExecutables(environment) {
+    return [
+        ...(environment.npm ?? []).map(executableNameFromNpmSpec),
+        ...(environment.pip ?? []).map(executableNameFromPipSpec),
+        ...(environment.binaries ?? []),
+        ...Object.values(environment.mcp ?? {})
+            .filter((server) => server.kind === "command")
+            .map((server) => firstCommandToken(server.command)),
+    ];
+}
+/** Map children share one bundle entrypoint per map step. */
+export function mapChildId(mapId) {
+    return `${mapId}:item`;
+}
+/** Managed placement rule (spec §4.1): all cloud steps run through the E2B claim path. */
+export function isCloudHostedStep(step) {
+    if (step.kind === "action")
+        return true;
+    return (step.kind === "code" || step.kind === "agent") && step.host?.kind === "cloud";
+}
+export function executableStepEnvironment(step) {
+    if ((step.kind === "code" || step.kind === "agent") && step.environment) {
+        return step.environment;
+    }
+    return undefined;
+}
+function stepRequiresEnvironmentTemplate(step) {
+    if (step.kind !== "code" && step.kind !== "agent")
+        return false;
+    if (!step.environment)
+        return false;
+    return isCloudHostedStep(step);
+}
+export function collectWorkflowEnvironments(ir) {
+    const byHash = new Map();
+    for (const step of Object.values(ir.steps)) {
+        const root = (step.kind === "code" || step.kind === "agent") && stepRequiresEnvironmentTemplate(step)
+            ? step.environment
+            : undefined;
+        if (root)
+            byHash.set(root.envHash, root);
+        if (step.kind === "map") {
+            const child = stepRequiresEnvironmentTemplate(step.step)
+                ? executableStepEnvironment(step.step)
+                : undefined;
+            if (child)
+                byHash.set(child.envHash, child);
+        }
+    }
+    return [...byHash.values()].sort((a, b) => a.envHash.localeCompare(b.envHash));
+}

package/node_modules/@reasonlayer/protocol/dist/permissions.d.ts

@@ -0,0 +1,5 @@
+export declare const PERMISSIONS: readonly ["org:read", "members:read", "members:write", "tokens:read", "tokens:write", "workflows:read", "workflows:delete", "workspace:write", "deployments:read", "deployments:write", "runs:read", "runs:write", "tasks:claim", "transcripts:read", "reviews:read", "reviews:resolve", "triggers:read", "triggers:write", "secrets:read", "secrets:write", "variables:read", "variables:write", "devices:read", "devices:write", "alerts:read", "alerts:write", "integrations:read", "integrations:write"];
+export type Permission = (typeof PERMISSIONS)[number];
+type PermissionResource = Permission extends `${infer Resource}:${string}` ? Resource : never;
+export type Scope = Permission | `${PermissionResource}:*` | "*";
+export {};

package/node_modules/@reasonlayer/protocol/dist/permissions.js

@@ -0,0 +1,30 @@
+export const PERMISSIONS = [
+    "org:read",
+    "members:read",
+    "members:write",
+    "tokens:read",
+    "tokens:write",
+    "workflows:read",
+    "workflows:delete",
+    "workspace:write",
+    "deployments:read",
+    "deployments:write",
+    "runs:read",
+    "runs:write",
+    "tasks:claim",
+    "transcripts:read",
+    "reviews:read",
+    "reviews:resolve",
+    "triggers:read",
+    "triggers:write",
+    "secrets:read",
+    "secrets:write",
+    "variables:read",
+    "variables:write",
+    "devices:read",
+    "devices:write",
+    "alerts:read",
+    "alerts:write",
+    "integrations:read",
+    "integrations:write",
+];