skedyul 1.2.43 → 1.2.48

package/dist/cli/utils/auth.d.ts

@@ -87,5 +87,8 @@ export interface ApiClientOptions {
     serverUrl: string;
     token?: string;
 }
-export declare function callCliApi<T>(options: ApiClientOptions, endpoint: string, body?: Record<string, unknown>): Promise<T>;
+export declare function callCliApi<T>(options: ApiClientOptions, endpoint: string, body?: Record<string, unknown>, init?: {
+    method?: 'GET' | 'POST';
+    query?: Record<string, string | undefined>;
+}): Promise<T>;
 export {};

package/dist/cli/utils/auth.js

@@ -442,31 +442,55 @@ async function openBrowser(url) {
     });
   }
 }
-async function callCliApi(options, endpoint, body) {
-  const url = `${options.serverUrl}/api/cli${endpoint}`;
+async function callCliApi(options, endpoint, body, init) {
+  let url = `${options.serverUrl}/api/cli${endpoint}`;
+  if (init?.query) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(init.query)) {
+      if (value !== void 0) {
+        params.set(key, value);
+      }
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+  }
   const headers = {
     "Content-Type": "application/json"
   };
   if (options.token) {
     headers["Authorization"] = `Bearer ${options.token}`;
   }
+  const method = init?.method ?? (body !== void 0 ? "POST" : "GET");
   const response = await fetch(url, {
-    method: "POST",
+    method,
     headers,
-    body: body ? JSON.stringify(body) : void 0
+    body: method === "POST" && body ? JSON.stringify(body) : void 0
   });
   if (!response.ok) {
-    const text = await response.text();
+    const text2 = await response.text();
     let message = `API error: ${response.status}`;
     try {
-      const json = JSON.parse(text);
+      const json = JSON.parse(text2);
       if (json.error) message = json.error;
     } catch {
-      if (text) message = text;
+      if (text2.startsWith("<!DOCTYPE") || text2.startsWith("<html")) {
+        message = `API error: ${response.status} (received HTML instead of JSON \u2014 is the route registered and allowed in proxy.ts?)`;
+      } else if (text2) {
+        message = text2.slice(0, 200);
+      }
     }
     throw new Error(message);
   }
-  return response.json();
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(
+      `Invalid JSON response from ${url} \u2014 received HTML or malformed body. Restart the web server if you added a new CLI route.`
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cli/utils/config.d.ts

@@ -1,4 +1,6 @@
 import type { ModelDefinition, RelationshipDefinition } from '../../config/types';
+import type { ProvisionConfig } from '../../config/app-config';
+import type { ToolRegistry, WebhookRegistry } from '../../types';
 export interface SkedyulAppConfig {
     name: string;
     handle: string;
@@ -20,6 +22,7 @@ export interface InstallEnvField {
     visibility?: 'visible' | 'encrypted';
     placeholder?: string;
     description?: string;
+    scope?: 'provision' | 'install';
 }
 export interface InstallConfigData {
     env?: Record<string, InstallEnvField>;
@@ -29,9 +32,29 @@ export interface InstallConfigData {
     relationships?: RelationshipDefinition[];
 }
 export declare function loadInstallConfig(projectDir?: string, debug?: boolean): Promise<InstallConfigData | null>;
+/**
+ * Load env from legacy install.config files only (not provision/env.ts).
+ */
+export declare function loadLegacyInstallConfig(projectDir?: string, debug?: boolean): Promise<InstallConfigData | null>;
 /**
  * Find and load the install handler from the project directory.
  * Returns the default export (install handler function) or null if not found.
  */
 export declare function loadInstallHandler(projectDir?: string): Promise<((ctx: unknown) => Promise<unknown>) | null>;
+/** Exclude provision-scoped vars mistakenly stored in install.env (legacy sync bug). */
+export declare function filterInstallScopedEnv(env: Record<string, InstallEnvField & {
+    scope?: string;
+}>): Record<string, InstallEnvField>;
+/** Env vars passed to the install workflow (install-scoped only). */
+export declare function filterEnvForInstallWorkflow(env: Record<string, string>, installConfig: InstallConfigData | null): Record<string, string>;
+/**
+ * Load provision config (env, models, pages) directly from src/provision/index.ts.
+ * Avoids resolving skedyul.config.ts dynamic imports which fail under the compiled CLI.
+ */
+export declare function loadProvisionConfig(projectDir?: string): Promise<ProvisionConfig | null>;
+/**
+ * Build the executable.config payload synced to Skedyul during dev serve.
+ * Includes full provision (env, models, pages) so Developer Console and install UI work.
+ */
+export declare function buildExecutableSyncConfig(registry: ToolRegistry, inputSchemaToJson: (schema: unknown) => unknown, projectDir?: string, webhookRegistry?: WebhookRegistry): Promise<Record<string, unknown>>;
 export declare function findRegistryPath(projectDir?: string): string | null;

package/dist/cli/utils/env-sync.d.ts

@@ -0,0 +1,46 @@
+import { type LinkConfig } from './link';
+import { type InstallEnvField } from './config';
+export type EnvConfigField = InstallEnvField;
+export declare function isInstallScopedField(field: EnvConfigField): boolean;
+export declare function isProvisionScopedField(field: EnvConfigField): boolean;
+export declare function applyEnvToProcess(env: Record<string, string>): void;
+export declare function buildProvisionEnvFields(): Promise<Array<{
+    key: string;
+    field: EnvConfigField;
+}>>;
+export declare function buildInstallScopedEnvFields(): Promise<Array<{
+    key: string;
+    field: EnvConfigField;
+}>>;
+/**
+ * Fetch env vars from Skedyul DB (decrypted) for the given scope.
+ */
+export declare function fetchEnvFromPlatform(linkConfig: LinkConfig, token: string, scope: 'provision' | 'install'): Promise<Record<string, string>>;
+/**
+ * Upsert provision-scoped env vars to Skedyul (APP_VERSION level).
+ */
+export declare function syncProvisionEnvToPlatform(linkConfig: LinkConfig, token: string, env: Record<string, string>, envFields?: Array<{
+    key: string;
+    field: EnvConfigField;
+}>, options?: {
+    quiet?: boolean;
+}): Promise<void>;
+/**
+ * Upsert install-scoped env vars to Skedyul (APP_INSTALL level).
+ */
+export declare function syncInstallEnvToPlatform(linkConfig: LinkConfig, token: string, env: Record<string, string>, envFields?: Array<{
+    key: string;
+    field: EnvConfigField;
+}>): Promise<void>;
+/** @deprecated Use fetchEnvFromPlatform with scope 'install' */
+export declare function buildInstallEnvFields(): Promise<Array<{
+    key: string;
+    field: EnvConfigField;
+}>>;
+/** Load install-scoped vars from local file (dev install cache). */
+export declare function loadLocalInstallEnv(workplaceSubdomain: string): Record<string, string>;
+/**
+ * Remove provision-scoped keys from the local .env file.
+ * Provision vars live in Skedyul DB — the local file is for install-scoped vars only.
+ */
+export declare function pruneProvisionKeysFromLocalEnv(workplaceSubdomain: string): Promise<string[]>;

package/dist/cli/utils/mcp-http-client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * MCP HTTP Client utilities for CLI commands.
+ *
+ * Provides helpers for making JSON-RPC calls to local MCP servers,
+ * matching the payload format used by the worker-compute activities.
+ */
+export interface McpJsonRpcResponse {
+    jsonrpc: string;
+    id: unknown;
+    result?: {
+        content?: Array<{
+            type?: string;
+            text?: unknown;
+        }>;
+        structuredContent?: Record<string, unknown>;
+        isError?: boolean;
+        tools?: unknown[];
+        cursor?: unknown;
+        billing?: unknown;
+    };
+    error?: {
+        code?: number;
+        message?: string;
+    };
+}
+export interface McpToolCallResult {
+    success: boolean;
+    output: unknown;
+    error?: string;
+    billing?: unknown;
+    cursor?: unknown;
+    isError?: boolean;
+}
+export interface McpToolCallOptions {
+    baseUrl: string;
+    toolName: string;
+    inputs?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+/**
+ * Make an HTTP request to a local server.
+ */
+export declare function makeHttpRequest(hostname: string, port: number, path: string, method: string, body?: unknown, timeoutMs?: number): Promise<{
+    status: number;
+    body: unknown;
+}>;
+/**
+ * POST a JSON-RPC request to an MCP server.
+ */
+export declare function postJsonRpc(baseUrl: string, method: string, params: unknown, timeoutMs?: number): Promise<McpJsonRpcResponse>;
+/**
+ * Check if a local MCP server is healthy.
+ */
+export declare function checkHealth(baseUrl: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Call tools/list on an MCP server.
+ */
+export declare function listMcpTools(baseUrl: string, timeoutMs?: number): Promise<{
+    success: boolean;
+    tools?: unknown[];
+    error?: string;
+}>;
+/**
+ * Call tools/call on an MCP server with the Skedyul payload format.
+ *
+ * Builds the same payload structure as worker-compute/src/activities/mcp-http.ts
+ */
+export declare function callMcpTool(options: McpToolCallOptions): Promise<McpToolCallResult>;
+/**
+ * Parse the MCP tools/call response into a structured result.
+ */
+export declare function parseMcpToolCallResult(response: McpJsonRpcResponse): McpToolCallResult;

package/dist/cli/utils/migration-approval.d.ts

@@ -0,0 +1,39 @@
+import type { LinkConfig } from './link';
+export type MigrationImpact = {
+    operationType: string;
+    resourceType: string;
+    resourceHandle: string;
+    affectedRecords?: number;
+    message?: string;
+    isDestructive?: boolean;
+};
+export type PendingMigrationInfo = {
+    migrationId: string;
+    impacts: MigrationImpact[];
+    timeoutMinutes: number;
+    createdAt: string;
+};
+export type SyncResourcesResult = {
+    tools?: {
+        synced: number;
+        disabled: number;
+    };
+    webhooks?: {
+        synced: number;
+        disabled: number;
+    };
+    internalModels?: {
+        modelsCreated: number;
+        modelsUpdated: number;
+        fieldsCreated: number;
+        relationshipsCreated: number;
+    };
+};
+export declare function promptForMigrationApproval(impacts: MigrationImpact[]): Promise<boolean>;
+export declare function approveMigrationViaCli(serverUrl: string, token: string, migrationId: string): Promise<void>;
+export declare function waitForMigrationCompletion(serverUrl: string, token: string, migrationId: string, timeoutMs?: number): Promise<{
+    completed: boolean;
+    timedOut: boolean;
+    denied: boolean;
+}>;
+export declare function syncResourcesWithMigrationApproval(linkConfig: LinkConfig, token: string, config: Record<string, unknown>): Promise<SyncResourcesResult>;

package/dist/cli/utils/mock-context.d.ts

@@ -1,22 +1,32 @@
-import { type MockContext } from '../../context/types';
+import { type AgentContext } from '../../context/types';
 /**
- * Load mock context from a JSON file
+ * Load agent context from a JSON file
  */
-export declare function loadMockContext(filePath: string): MockContext;
+export declare function loadContext(filePath: string): AgentContext;
+/** @deprecated Use loadContext instead */
+export declare const loadMockContext: typeof loadContext;
+/** Read prospect CRM data from context (associations shape or legacy contexts). */
+export declare function getProspectData(context: AgentContext | null | undefined): Record<string, unknown> | undefined;
 /**
- * Parse a quick mock sender string
+ * Parse a quick sender string
  * Format: "Display Name:kind" or "Display Name:kind:model"
  * Examples:
  *   "John Smith:contact"
  *   "John Smith:contact:customer"
  *   "Sarah Jones:member"
  */
-export declare function parseMockSender(input: string): MockContext['sender'];
+export declare function parseSender(input: string): AgentContext['sender'];
+/** @deprecated Use parseSender instead */
+export declare const parseMockSender: typeof parseSender;
 /**
- * Build a complete mock context from sender and optional contexts
+ * Build a complete context from sender and optional contexts
  */
-export declare function buildMockContext(sender: MockContext['sender'], contexts?: MockContext['contexts']): MockContext;
+export declare function buildContext(sender: AgentContext['sender'], contexts?: AgentContext['contexts']): AgentContext;
+/** @deprecated Use buildContext instead */
+export declare const buildMockContext: typeof buildContext;
 /**
- * Merge mock context with defaults
+ * Merge context with defaults
  */
-export declare function mergeMockContext(base: Partial<MockContext>, overrides: Partial<MockContext>): MockContext;
+export declare function mergeContext(base: Partial<AgentContext>, overrides: Partial<AgentContext>): AgentContext;
+/** @deprecated Use mergeContext instead */
+export declare const mergeMockContext: typeof mergeContext;

package/dist/cli/utils/sse.d.ts

@@ -96,5 +96,38 @@ export interface ChatEvent {
         result: unknown;
         /** Provider-specific options (e.g., Gemini's thought_signature for tool call replay) */
         providerOptions?: Record<string, unknown>;
+        /** AI SDK tool handle (e.g., "load_skill" for "system:skill:load") - needed for correct message replay */
+        handle?: string;
     }>;
+    /** Sent message event (explicit message mode) */
+    sentMessage?: {
+        messageId: string;
+        content: string;
+        type: 'intermediate' | 'final' | 'scheduled';
+        scheduledFor?: string;
+    };
+    /** All messages sent during this turn (for explicit message mode) */
+    sentMessages?: Array<{
+        id: string;
+        rawContent: string;
+        transformedContent: string;
+        type: 'intermediate' | 'final' | 'scheduled';
+        scheduledFor?: string;
+        timestamp?: string;
+        index?: number;
+        /** Structured sendAt object from the agent tool */
+        sendAt?: {
+            mode: 'relative' | 'absolute';
+            amount?: number;
+            unit?: string;
+            timeWindow?: string;
+            scheduleAt?: string;
+        };
+    }>;
+    /** Scheduling defaults from agent config (sandbox mode only) */
+    schedulingDefaults?: {
+        cancelOnActivity?: boolean;
+        requiresApproval?: boolean;
+        timeWindow?: string;
+    };
 }

package/dist/cli/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ToolRegistry } from '../types';
+import type { ToolRegistry, WebhookRegistry } from '../types';
 export interface ParsedArgs {
     flags: Record<string, string | boolean>;
     positional: string[];
@@ -23,6 +23,10 @@ export declare function loadTypeScriptFile(absolutePath: string): Promise<unknow
  * Load a registry from a JS/TS file
  */
 export declare function loadRegistry(registryPath: string): Promise<ToolRegistry>;
+/**
+ * Load webhook registry from the same module as the tool registry.
+ */
+export declare function loadWebhookRegistry(registryPath: string): Promise<WebhookRegistry>;
 /**
  * Format JSON for console output with optional color
  */

package/dist/compiler/types.d.ts

@@ -79,22 +79,24 @@ export interface IRMemoryConfig {
  * Policy configuration
  */
 export interface PolicyConfig {
-    response?: {
-        requiresApproval: boolean;
-        conditions?: string[];
+    messages?: {
+        send?: {
+            requiresApproval?: boolean;
+        };
+        schedule?: {
+            requiresApproval?: boolean;
+        };
+    };
+    tools?: {
+        externalRequiresApproval?: boolean;
+        systemRequiresApproval?: boolean;
     };
-    rules: string[];
 }
 /**
  * Runtime configuration
  */
 export interface IRRuntimeConfig {
     model: string;
-    timeout: string;
-    retry?: {
-        attempts?: number;
-        backoff?: 'linear' | 'exponential';
-    };
 }
 /**
  * Agent Intermediate Representation (IR)

package/dist/config/schema-loader.d.ts

@@ -50,6 +50,15 @@ export interface BackendModelDefinition {
     icon?: string;
     fields?: BackendFieldDefinition[];
 }
+/**
+ * Backend-compatible field appearance.
+ */
+export interface BackendFieldAppearance {
+    leftIcon?: string;
+    rightIcon?: string;
+    placeholder?: string;
+    helpText?: string;
+}
 /**
  * Backend-compatible field definition.
  */
@@ -57,7 +66,8 @@ export interface BackendFieldDefinition {
     handle: string;
     label: string;
     type: string;
-    helpText?: string | null;
+    description?: string;
+    appearance?: BackendFieldAppearance;
     isList?: boolean;
     isUnique?: boolean;
     requirement?: string;
@@ -71,6 +81,7 @@ export interface BackendFieldDefinition {
             label: string;
             color?: string | null;
         }>;
+        limitChoices?: number;
     };
 }
 /**
@@ -118,8 +129,10 @@ export interface BackendPageDefinition {
 export interface BackendNavigationItemDefinition {
     label: string;
     icon?: string;
-    path: string;
+    path?: string;
+    kind?: 'section' | 'group';
     sortIndex?: number;
+    children?: BackendNavigationItemDefinition[];
 }
 /**
  * Backend-compatible navigation definition.

package/dist/config/types/model.d.ts

@@ -158,6 +158,8 @@ export interface ModelDefinition extends BaseDefinition {
     addDefaultPages?: boolean;
     /** Whether to create a navigation item for this model (default: false for provisioning) */
     addNavigation?: boolean;
+    /** Root path for developer resource UI (e.g., '/access_requests'). Links internal model to a provision.pages entry. */
+    page?: string;
 }
 /**
  * One side of a relationship link.

package/dist/config/types/page.d.ts

@@ -14,6 +14,13 @@ import type { NavigationConfig } from './navigation';
  * - 'list': Shows multiple records (e.g., /phone-numbers)
  */
 export type PageType = 'instance' | 'list';
+/**
+ * Page audience - who can view this page.
+ * - 'install': Visible only to app installers (default)
+ * - 'developer': Visible only to app developers/owners in Developer Console
+ * - 'both': Visible in both contexts
+ */
+export type PageAudience = 'install' | 'developer' | 'both';
 /**
  * Page filter for list pages.
  * Defines which model and optional filter criteria to use.
@@ -34,6 +41,8 @@ export interface PageDefinition extends BaseDefinition {
     path: string;
     /** When true, this page is the default landing page for the app */
     default?: boolean;
+    /** Page audience: 'install' (default), 'developer', or 'both' */
+    audience?: PageAudience;
     /**
      * Navigation configuration:
      * - true/false: show/hide in auto-generated navigation

package/dist/context/index.d.ts

@@ -1,2 +1,2 @@
-export { CRMContextSchema, SenderContextSchema, ThreadContextItemSchema, ThreadInfoSchema, AgentContextSchema, MockSenderContextSchema, MockThreadContextSchema, MockContextSchema, SandboxConfigSchema, type CRMContext, type SenderContext, type ThreadContextItem, type ThreadInfo, type AgentContext, type MockSenderContext, type MockThreadContext, type MockContext, type SandboxConfig, } from './types';
-export { buildAgentContext, buildContextFromMock, formatContextForPrompt, getContextByHandle, getContextByModel, } from './resolver';
+export { CRMContextSchema, SenderContextSchema, ThreadContextItemSchema, ThreadInfoSchema, SandboxConfigSchema, SubscriptionSchema, AssociationSchema, ContactSchema, AgentSenderContextSchema, AgentThreadContextSchema, AgentContextSchema, ContextIssueSeveritySchema, ContextIssueTypeSchema, ContextIssueSchema, ContextValidationResultSchema, MockSubscriptionSchema, MockAssociationSchema, MockContactSchema, MockSenderContextSchema, MockThreadContextSchema, MockContextSchema, type CRMContext, type SenderContext, type ThreadContextItem, type ThreadInfo, type SandboxConfig, type Subscription, type Association, type Contact, type AgentSenderContext, type AgentThreadContext, type AgentContext, type ContextIssueSeverity, type ContextIssueType, type ContextIssue, type ContextValidationResult, type MockSubscription, type MockAssociation, type MockContact, type MockSenderContext, type MockThreadContext, type MockContext, } from './types';
+export { buildAgentContext, formatContextForPrompt, getContextByHandle, getContextByModel, getAssociationByModel, } from './resolver';

package/dist/context/resolver.d.ts

@@ -1,51 +1,52 @@
-import type { AgentContext, ThreadContextItem, MockContext } from './types';
+import type { AgentContext, AgentThreadContext } from './types';
 /**
- * Build agent context from thread data
- * This is a utility for building the context object that gets passed to agents
+ * Build agent context from thread participant data.
+ *
+ * This creates the unified AgentContext shape used by both sandbox and production.
  */
 export declare function buildAgentContext(params: {
-    thread: {
-        id: string;
-        title?: string;
-        status?: string;
-        kind?: string;
-    };
     sender: {
-        kind: 'CONTACT' | 'MEMBER' | 'AGENT' | 'WORKFLOW';
+        kind: 'contact' | 'member';
         displayName?: string;
-        email?: string;
         role?: string;
         permissions?: string[];
-        crm?: {
-            model: string;
-            instanceId: string;
-            data: Record<string, unknown>;
+        contact?: {
+            id?: string;
+            name?: string;
+            subscription?: {
+                identifierValue: string;
+                channelHandle?: string;
+            };
+            associations?: Record<string, {
+                id?: string;
+                data: Record<string, unknown>;
+            }>;
         };
     };
     contexts?: Array<{
         handle: string;
         model: string;
-        instanceId: string;
-        data?: Record<string, unknown>;
+        data: Record<string, unknown>;
     }>;
-    workplace?: {
-        id: string;
-        name?: string;
-    };
 }): AgentContext;
 /**
- * Build agent context from mock context (for sandbox testing)
- */
-export declare function buildContextFromMock(mockContext: MockContext, threadId: string, workplaceId?: string): AgentContext;
-/**
- * Format context for system prompt injection
+ * Format context for system prompt injection.
+ *
+ * This creates the "Current Context" section that gets injected into the system prompt.
  */
 export declare function formatContextForPrompt(context: AgentContext): string;
 /**
  * Get CRM data from context by model handle
  */
-export declare function getContextByHandle(context: AgentContext, handle: string): ThreadContextItem | undefined;
+export declare function getContextByHandle(context: AgentContext, handle: string): AgentThreadContext | undefined;
 /**
  * Get CRM data from context by model type
  */
-export declare function getContextByModel(context: AgentContext, model: string): ThreadContextItem | undefined;
+export declare function getContextByModel(context: AgentContext, model: string): AgentThreadContext | undefined;
+/**
+ * Get an association from the sender's contact by model handle
+ */
+export declare function getAssociationByModel(context: AgentContext, model: string): {
+    id?: string;
+    data: Record<string, unknown>;
+} | undefined;