skedyul 1.2.40 → 1.2.43

package/dist/cli/utils/auth.js

@@ -0,0 +1,495 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/utils/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  callCliApi: () => callCliApi,
+  clearAllProfiles: () => clearAllProfiles,
+  clearCredentials: () => clearCredentials,
+  deleteProfile: () => deleteProfile,
+  ensureUniqueProfileName: () => ensureUniqueProfileName,
+  generateProfileName: () => generateProfileName,
+  getActiveProfileName: () => getActiveProfileName,
+  getConfig: () => getConfig,
+  getCredentials: () => getCredentials,
+  getLocalConfig: () => getLocalConfig,
+  getNgrokAuthtoken: () => getNgrokAuthtoken,
+  getProfile: () => getProfile,
+  getProfiles: () => getProfiles,
+  getServerUrl: () => getServerUrl,
+  listProfiles: () => listProfiles,
+  saveConfig: () => saveConfig,
+  saveCredentials: () => saveCredentials,
+  saveProfile: () => saveProfile,
+  saveProfiles: () => saveProfiles,
+  setActiveProfile: () => setActiveProfile,
+  setNgrokAuthtoken: () => setNgrokAuthtoken,
+  startOAuthCallback: () => startOAuthCallback
+});
+module.exports = __toCommonJS(auth_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var http = __toESM(require("http"));
+var SKEDYUL_HOME_DIR = path.join(os.homedir(), ".skedyul");
+var PROFILES_FILE = path.join(SKEDYUL_HOME_DIR, "profiles.json");
+var CONFIG_FILE = path.join(SKEDYUL_HOME_DIR, "config.json");
+var LEGACY_CREDENTIALS_FILE = path.join(SKEDYUL_HOME_DIR, "credentials.json");
+var LOCAL_CONFIG_FILE = ".skedyul.local.json";
+var DEFAULT_SERVER_URL = "https://admin.skedyul.it";
+function ensureHomeDir() {
+  if (!fs.existsSync(SKEDYUL_HOME_DIR)) {
+    fs.mkdirSync(SKEDYUL_HOME_DIR, { recursive: true, mode: 448 });
+  }
+}
+function generateProfileName(serverUrl) {
+  try {
+    const url = new URL(serverUrl);
+    const hostname = url.hostname.toLowerCase();
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "local";
+    }
+    if (hostname.includes("staging")) {
+      return "staging";
+    }
+    if (hostname === "admin.skedyul.it" || hostname === "app.skedyul.com") {
+      return "production";
+    }
+    const parts = hostname.split(".");
+    if (parts.length > 0) {
+      return parts[0].replace(/[^a-z0-9-]/g, "");
+    }
+    return "default";
+  } catch {
+    return "default";
+  }
+}
+function ensureUniqueProfileName(baseName, existingProfiles) {
+  if (!existingProfiles[baseName]) {
+    return baseName;
+  }
+  let counter = 2;
+  while (existingProfiles[`${baseName}-${counter}`]) {
+    counter++;
+  }
+  return `${baseName}-${counter}`;
+}
+function migrateLegacyCredentials() {
+  if (!fs.existsSync(LEGACY_CREDENTIALS_FILE)) {
+    return;
+  }
+  if (fs.existsSync(PROFILES_FILE)) {
+    return;
+  }
+  try {
+    const content = fs.readFileSync(LEGACY_CREDENTIALS_FILE, "utf-8");
+    const legacy = JSON.parse(content);
+    const profileName = generateProfileName(legacy.serverUrl);
+    const profile = {
+      serverUrl: legacy.serverUrl,
+      token: legacy.token,
+      userId: legacy.userId,
+      username: legacy.username,
+      email: legacy.email,
+      expiresAt: legacy.expiresAt,
+      createdAt: legacy.createdAt
+    };
+    const profilesFile = {
+      profiles: {
+        [profileName]: profile
+      }
+    };
+    ensureHomeDir();
+    fs.writeFileSync(PROFILES_FILE, JSON.stringify(profilesFile, null, 2), {
+      mode: 384
+    });
+    const config = getConfig();
+    config.activeProfile = profileName;
+    saveConfig(config);
+    fs.unlinkSync(LEGACY_CREDENTIALS_FILE);
+    console.error(`Migrated credentials to profile: ${profileName}`);
+  } catch (error) {
+    console.error("Failed to migrate legacy credentials:", error);
+  }
+}
+function getProfiles() {
+  migrateLegacyCredentials();
+  if (!fs.existsSync(PROFILES_FILE)) {
+    return { profiles: {} };
+  }
+  try {
+    const content = fs.readFileSync(PROFILES_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { profiles: {} };
+  }
+}
+function saveProfiles(profilesFile) {
+  ensureHomeDir();
+  fs.writeFileSync(PROFILES_FILE, JSON.stringify(profilesFile, null, 2), {
+    mode: 384
+  });
+}
+function getProfile(name) {
+  const profilesFile = getProfiles();
+  const profile = profilesFile.profiles[name];
+  if (!profile) {
+    return null;
+  }
+  if (profile.expiresAt) {
+    const expiresAt = new Date(profile.expiresAt);
+    if (expiresAt < /* @__PURE__ */ new Date()) {
+      return null;
+    }
+  }
+  return profile;
+}
+function saveProfile(name, profile) {
+  const profilesFile = getProfiles();
+  profilesFile.profiles[name] = profile;
+  saveProfiles(profilesFile);
+}
+function deleteProfile(name) {
+  const profilesFile = getProfiles();
+  if (!profilesFile.profiles[name]) {
+    return false;
+  }
+  delete profilesFile.profiles[name];
+  saveProfiles(profilesFile);
+  const config = getConfig();
+  if (config.activeProfile === name) {
+    const remainingProfiles = Object.keys(profilesFile.profiles);
+    config.activeProfile = remainingProfiles[0] ?? void 0;
+    saveConfig(config);
+  }
+  return true;
+}
+function listProfiles() {
+  const profilesFile = getProfiles();
+  const config = getConfig();
+  const activeProfile = config.activeProfile;
+  return Object.entries(profilesFile.profiles).map(([name, profile]) => {
+    let isExpired = false;
+    if (profile.expiresAt) {
+      isExpired = new Date(profile.expiresAt) < /* @__PURE__ */ new Date();
+    }
+    return {
+      name,
+      profile,
+      isActive: name === activeProfile,
+      isExpired
+    };
+  });
+}
+function clearAllProfiles() {
+  if (fs.existsSync(PROFILES_FILE)) {
+    fs.unlinkSync(PROFILES_FILE);
+  }
+  const config = getConfig();
+  delete config.activeProfile;
+  saveConfig(config);
+}
+function getActiveProfileName() {
+  const config = getConfig();
+  return config.activeProfile ?? null;
+}
+function setActiveProfile(name) {
+  const profilesFile = getProfiles();
+  if (!profilesFile.profiles[name]) {
+    return false;
+  }
+  const config = getConfig();
+  config.activeProfile = name;
+  saveConfig(config);
+  return true;
+}
+function getCredentials() {
+  const activeProfileName = getActiveProfileName();
+  if (!activeProfileName) {
+    return null;
+  }
+  const profile = getProfile(activeProfileName);
+  if (!profile) {
+    return null;
+  }
+  return {
+    token: profile.token,
+    userId: profile.userId,
+    username: profile.username,
+    email: profile.email,
+    serverUrl: profile.serverUrl,
+    expiresAt: profile.expiresAt,
+    createdAt: profile.createdAt
+  };
+}
+function saveCredentials(credentials, profileName) {
+  const name = profileName ?? generateProfileName(credentials.serverUrl);
+  const profilesFile = getProfiles();
+  const finalName = profileName ? name : ensureUniqueProfileName(name, profilesFile.profiles);
+  const profile = {
+    serverUrl: credentials.serverUrl,
+    token: credentials.token,
+    userId: credentials.userId,
+    username: credentials.username,
+    email: credentials.email,
+    expiresAt: credentials.expiresAt,
+    createdAt: credentials.createdAt
+  };
+  saveProfile(finalName, profile);
+  const config = getConfig();
+  config.activeProfile = finalName;
+  saveConfig(config);
+  return finalName;
+}
+function clearCredentials() {
+  const activeProfileName = getActiveProfileName();
+  if (activeProfileName) {
+    deleteProfile(activeProfileName);
+  }
+}
+function getConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { defaultServer: DEFAULT_SERVER_URL };
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { defaultServer: DEFAULT_SERVER_URL };
+  }
+}
+function saveConfig(config) {
+  ensureHomeDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getLocalConfig() {
+  const localConfigPath = path.join(process.cwd(), LOCAL_CONFIG_FILE);
+  if (!fs.existsSync(localConfigPath)) {
+    return {};
+  }
+  try {
+    const content = fs.readFileSync(localConfigPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function getServerUrl(override) {
+  if (override) return override;
+  const localConfig = getLocalConfig();
+  if (localConfig.serverUrl) return localConfig.serverUrl;
+  const credentials = getCredentials();
+  if (credentials?.serverUrl) return credentials.serverUrl;
+  return getConfig().defaultServer;
+}
+function getNgrokAuthtoken() {
+  return getConfig().ngrokAuthtoken;
+}
+function setNgrokAuthtoken(authtoken) {
+  const config = getConfig();
+  config.ngrokAuthtoken = authtoken;
+  saveConfig(config);
+}
+async function startOAuthCallback(serverUrl) {
+  return new Promise((resolve, reject) => {
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      const searchParams = url.searchParams;
+      if (url.pathname === "/callback") {
+        const token = searchParams.get("token");
+        const userId = searchParams.get("userId");
+        const username = searchParams.get("username");
+        const email = searchParams.get("email");
+        const expiresAt = searchParams.get("expiresAt");
+        const error = searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1 style="color: #e53e3e;">Authentication Failed</h1>
+                <p>${error}</p>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+          cleanup();
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (!token || !userId || !username || !email) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1 style="color: #e53e3e;">Authentication Failed</h1>
+                <p>Missing required parameters in callback</p>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+          cleanup();
+          server.close();
+          reject(new Error("Missing required parameters in callback"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1 style="color: #38a169;">Authentication Successful</h1>
+              <p>Logged in as <strong>${email}</strong></p>
+              <p>You can close this window and return to the terminal.</p>
+            </body>
+          </html>
+        `);
+        cleanup();
+        server.close();
+        resolve({
+          token,
+          userId,
+          username,
+          email,
+          expiresAt
+        });
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        cleanup();
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      const callbackUrl = `http://localhost:${port}/callback`;
+      const authUrl = `${serverUrl}/api/cli/auth?redirect=${encodeURIComponent(callbackUrl)}`;
+      console.log(`Opening browser for authentication...`);
+      console.log(`If browser doesn't open, visit: ${authUrl}`);
+      console.log(`Waiting for callback on ${callbackUrl}...`);
+      openBrowser(authUrl).catch(() => {
+        console.log(`(Could not open browser automatically)`);
+      });
+    });
+    server.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+    timeoutId = setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function openBrowser(url) {
+  try {
+    const open = await import("open");
+    await open.default(url);
+  } catch {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${url}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+    return new Promise((resolve, reject) => {
+      exec(command, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+}
+async function callCliApi(options, endpoint, body) {
+  const url = `${options.serverUrl}/api/cli${endpoint}`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.token) {
+    headers["Authorization"] = `Bearer ${options.token}`;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    let message = `API error: ${response.status}`;
+    try {
+      const json = JSON.parse(text);
+      if (json.error) message = json.error;
+    } catch {
+      if (text) message = text;
+    }
+    throw new Error(message);
+  }
+  return response.json();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callCliApi,
+  clearAllProfiles,
+  clearCredentials,
+  deleteProfile,
+  ensureUniqueProfileName,
+  generateProfileName,
+  getActiveProfileName,
+  getConfig,
+  getCredentials,
+  getLocalConfig,
+  getNgrokAuthtoken,
+  getProfile,
+  getProfiles,
+  getServerUrl,
+  listProfiles,
+  saveConfig,
+  saveCredentials,
+  saveProfile,
+  saveProfiles,
+  setActiveProfile,
+  setNgrokAuthtoken,
+  startOAuthCallback
+});

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

@@ -0,0 +1,22 @@
+import { type MockContext } from '../../context/types';
+/**
+ * Load mock context from a JSON file
+ */
+export declare function loadMockContext(filePath: string): MockContext;
+/**
+ * Parse a quick mock 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'];
+/**
+ * Build a complete mock context from sender and optional contexts
+ */
+export declare function buildMockContext(sender: MockContext['sender'], contexts?: MockContext['contexts']): MockContext;
+/**
+ * Merge mock context with defaults
+ */
+export declare function mergeMockContext(base: Partial<MockContext>, overrides: Partial<MockContext>): MockContext;

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

@@ -0,0 +1,100 @@
+/**
+ * SSE (Server-Sent Events) stream consumer for Node.js CLI.
+ * Parses SSE events from a fetch response stream.
+ */
+export interface SSEEvent {
+    data: string;
+    event?: string;
+    id?: string;
+}
+/**
+ * Parse SSE events from a ReadableStream.
+ * Yields parsed JSON data from each SSE event.
+ */
+export declare function parseSSEStream<T>(response: Response, debug?: boolean): AsyncGenerator<T>;
+/**
+ * Fetch an SSE endpoint and yield parsed events.
+ */
+export declare function fetchSSE<T>(url: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}): AsyncGenerator<T>;
+/**
+ * Chat event types from the CLI chat endpoint.
+ */
+export interface ChatEvent {
+    threadId?: string;
+    threadTitle?: string;
+    message?: string;
+    thought?: string;
+    thoughtComplete?: boolean;
+    durationMs?: number;
+    thoughts?: Array<{
+        content: string;
+        durationMs: number;
+    }>;
+    data?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    context?: Array<{
+        model?: string;
+        hint?: string;
+        id: string;
+        label: string;
+        data?: Record<string, unknown>;
+    }>;
+    toolCall?: {
+        name: string;
+        status: 'started' | 'completed' | 'failed';
+        args?: Record<string, unknown>;
+        durationMs?: number;
+        resultSummary?: string;
+        autoApproved?: boolean;
+    };
+    /** Pending approval request for a tool that requires user confirmation */
+    pendingApproval?: {
+        toolCallId: string;
+        toolName: string;
+        displayName: string;
+        args: Record<string, unknown>;
+    };
+    /** Name of the agent currently responding (for multi-stage agent runs) */
+    agentName?: string;
+    /** Whether this event is from a child agent invocation (for visual hierarchy in CLI) */
+    isChildAgent?: boolean;
+    /** Full output from an agent stage (for debugging multi-stage pipelines) */
+    agentOutput?: string;
+    done?: boolean;
+    initial?: boolean;
+    error?: string;
+    sandbox?: boolean;
+    /** Updated mock context after tool execution (sandbox mode only) */
+    updatedMockContext?: {
+        sender: {
+            displayName?: string;
+            kind: 'contact' | 'member';
+            role?: string;
+            permissions?: string[];
+            crm?: {
+                model: string;
+                data: Record<string, unknown>;
+            };
+        };
+        contexts?: Array<{
+            handle: string;
+            model: string;
+            data: Record<string, unknown>;
+        }>;
+    };
+    /** Tool calls from this turn with their results (for accumulating tool history) */
+    toolCalls?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+        result: unknown;
+        /** Provider-specific options (e.g., Gemini's thought_signature for tool call replay) */
+        providerOptions?: Record<string, unknown>;
+    }>;
+}

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,12 @@
+import type { SkillYAML } from '../skills/types';
+import type { AgentIR, WorkflowIR, CompilationResult } from './types';
+/**
+ * Compile agent YAML to IR
+ */
+export declare function compileAgent(yamlContent: string, options?: {
+    skillResolver?: (handle: string) => Promise<SkillYAML | null>;
+}): Promise<CompilationResult<AgentIR>>;
+/**
+ * Compile workflow YAML to IR
+ */
+export declare function compileWorkflow(yamlContent: string): Promise<CompilationResult<WorkflowIR>>;

package/dist/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { compileAgent, compileWorkflow } from './compiler';
+export type { ValidationError, ValidationWarning, ResolvedPersona, ResolvedTool, EventConfig, IRMemoryConfig, PolicyConfig, IRRuntimeConfig, AgentIR, WorkflowStepIR, WorkflowIR, CompilationResult, } from './types';