skedyul 1.7.26 → 1.7.28

package/dist/cli/api/index.js

@@ -0,0 +1,802 @@
+"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/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  approveMigration: () => approveMigration,
+  apps: () => apps,
+  crm: () => crm,
+  deployWorkflow: () => deployWorkflow,
+  diffSchema: () => diffSchema,
+  getInstallation: () => getInstallation,
+  getWorkflow: () => getWorkflow,
+  getWorkflowRun: () => getWorkflowRun,
+  getWorkflowSchema: () => getWorkflowSchema,
+  getWorkplaceToken: () => getWorkplaceToken,
+  heartbeat: () => heartbeat,
+  installApp: () => installApp,
+  invokeTool: () => invokeTool,
+  linkApp: () => linkApp,
+  listModels: () => listModels,
+  listTools: () => listTools,
+  listWorkflowVersions: () => listWorkflowVersions,
+  listWorkflows: () => listWorkflows,
+  listWorkplaces: () => listWorkplaces,
+  publishWorkflow: () => publishWorkflow,
+  pullSchema: () => pullSchema,
+  pullWorkflow: () => pullWorkflow,
+  pushSchema: () => pushSchema,
+  registerEndpoint: () => registerEndpoint,
+  runWorkflow: () => runWorkflow,
+  syncResources: () => syncResources,
+  uninstallApp: () => uninstallApp,
+  unregisterEndpoint: () => unregisterEndpoint,
+  validateWorkflow: () => validateWorkflow,
+  validateWorkflowContent: () => validateWorkflowContent,
+  workflows: () => workflows,
+  workplaces: () => workplaces
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/cli/utils/auth.ts
+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");
+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,
+    headers,
+    body: method === "POST" && body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const text2 = await response.text();
+    let message = `API error: ${response.status}`;
+    try {
+      const json = JSON.parse(text2);
+      if (json.error) message = json.error;
+    } catch {
+      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);
+  }
+  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.`
+    );
+  }
+}
+
+// src/cli/api/context.ts
+function cliApi(ctx) {
+  return {
+    serverUrl: ctx.serverUrl,
+    token: ctx.token
+  };
+}
+async function getWorkplaceToken(ctx, workplaceSubdomain) {
+  return callCliApi(cliApi(ctx), "/workplace-token", {
+    workplaceSubdomain
+  });
+}
+async function listWorkplaces(ctx) {
+  const result = await callCliApi(
+    cliApi(ctx),
+    "/workplaces",
+    void 0,
+    { method: "GET" }
+  );
+  return result.workplaces;
+}
+var workplaces = {
+  list: listWorkplaces,
+  getWorkplaceToken
+};
+
+// src/cli/api/crm.ts
+async function listModels(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(
+    cliApi(ctx),
+    "/crm-models",
+    void 0,
+    { method: "GET", query: { workplaceId: workplaceToken.workplaceId } }
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list models");
+  }
+  return result.models;
+}
+async function pullSchema(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(
+    cliApi(ctx),
+    "/crm-schema",
+    void 0,
+    { method: "GET", query: { workplaceId: workplaceToken.workplaceId } }
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Failed to pull schema");
+  }
+  return { schema: result.schema, workplaceName: result.workplaceName };
+}
+async function postSchema(ctx, workplace, schema, options) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/crm-schema", {
+    workplace,
+    workplaceId: workplaceToken.workplaceId,
+    schema,
+    dryRun: options.dryRun ?? false,
+    autoApprove: options.autoApprove ?? false,
+    schemaName: schema.name,
+    schemaVersion: schema.version
+  });
+}
+async function diffSchema(ctx, workplace, schema) {
+  return postSchema(ctx, workplace, schema, { dryRun: true });
+}
+async function approveMigration(ctx, migrationId) {
+  await callCliApi(cliApi(ctx), "/approve-migration", { migrationId });
+}
+async function pushSchema(ctx, workplace, schema, options = {}) {
+  const result = await postSchema(ctx, workplace, schema, {
+    dryRun: options.dryRun ?? false,
+    autoApprove: options.autoApprove ?? false
+  });
+  if (!options.dryRun && options.autoApprove && result.requiresApproval && result.migrationId) {
+    await approveMigration(ctx, result.migrationId);
+    return {
+      ...result,
+      requiresApproval: false
+    };
+  }
+  return result;
+}
+var crm = {
+  listModels,
+  pullSchema,
+  diffSchema,
+  pushSchema,
+  approveMigration
+};
+
+// src/cli/api/workflows.ts
+var import_yaml = require("yaml");
+
+// src/workflows/types.ts
+var import_v43 = require("zod/v4");
+
+// src/events/types.ts
+var import_v4 = require("zod/v4");
+var ThreadEventTypeSchema = import_v4.z.enum([
+  // Message events
+  "thread.message.received",
+  "thread.message.sent",
+  "thread.attachment.received",
+  // Participant events
+  "thread.participant.joined",
+  "thread.participant.left",
+  "thread.participant.mentioned",
+  // Context events
+  "thread.context.changed",
+  "thread.status.changed",
+  // Agent/Workflow events
+  "thread.agent.delegated",
+  "thread.agent.completed",
+  "thread.workflow.triggered",
+  "thread.workflow.completed",
+  // Scheduled events
+  "thread.follow_up.due",
+  "thread.reminder.due",
+  // Signal events
+  "thread.signal.created"
+]);
+var CustomEventTypeSchema = import_v4.z.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
+  message: "Custom event type must match pattern: custom.{namespace}.{event}"
+});
+var EventTypeSchema = import_v4.z.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
+var ParticipantKindSchema = import_v4.z.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
+var BaseEventPayloadSchema = import_v4.z.object({
+  threadId: import_v4.z.string(),
+  workplaceId: import_v4.z.string(),
+  timestamp: import_v4.z.string().datetime().optional()
+});
+var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
+  message: import_v4.z.object({
+    id: import_v4.z.string(),
+    content: import_v4.z.string(),
+    senderId: import_v4.z.string().optional()
+  }),
+  participant: import_v4.z.object({
+    id: import_v4.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v4.z.string().optional()
+  }).optional(),
+  isFirstMessage: import_v4.z.boolean().optional(),
+  messageCount: import_v4.z.number().optional()
+});
+var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
+  participant: import_v4.z.object({
+    id: import_v4.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v4.z.string().optional(),
+    contactId: import_v4.z.string().optional(),
+    memberId: import_v4.z.string().optional(),
+    agentId: import_v4.z.string().optional(),
+    workflowId: import_v4.z.string().optional()
+  })
+});
+var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  context: import_v4.z.object({
+    handle: import_v4.z.string(),
+    model: import_v4.z.string(),
+    instanceId: import_v4.z.string()
+  }),
+  change: import_v4.z.object({
+    field: import_v4.z.string().optional(),
+    oldValue: import_v4.z.unknown().optional(),
+    newValue: import_v4.z.unknown().optional()
+  }).optional()
+});
+var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  oldStatus: import_v4.z.string(),
+  newStatus: import_v4.z.string()
+});
+var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
+  scheduledEventId: import_v4.z.string(),
+  reason: import_v4.z.string().optional(),
+  context: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional()
+});
+var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
+  agentId: import_v4.z.string().optional(),
+  workflowId: import_v4.z.string().optional(),
+  workflowRunId: import_v4.z.string().optional(),
+  outputs: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional(),
+  error: import_v4.z.string().optional()
+});
+var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
+  data: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional()
+});
+var ThreadEventPayloadSchema = import_v4.z.union([
+  MessageEventPayloadSchema,
+  ParticipantEventPayloadSchema,
+  ContextChangedPayloadSchema,
+  StatusChangedPayloadSchema,
+  ScheduledEventPayloadSchema,
+  AgentWorkflowEventPayloadSchema,
+  CustomEventPayloadSchema
+]);
+var ThreadEventSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  threadId: import_v4.z.string(),
+  type: EventTypeSchema,
+  payload: ThreadEventPayloadSchema,
+  emittedBy: import_v4.z.string().optional(),
+  createdAt: import_v4.z.string().datetime()
+});
+var CreateThreadEventInputSchema = import_v4.z.object({
+  threadId: import_v4.z.string(),
+  type: EventTypeSchema,
+  payload: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()),
+  emittedBy: import_v4.z.string().optional()
+});
+var EventSubscriptionSchema = import_v4.z.object({
+  subscribes: import_v4.z.array(EventTypeSchema),
+  condition: import_v4.z.string().optional(),
+  cancels: import_v4.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v4.z.string().optional()
+});
+var EventWaitSchema = import_v4.z.object({
+  event: EventTypeSchema,
+  timeout: import_v4.z.string().optional(),
+  onTimeout: import_v4.z.string().optional()
+});
+var EventsConfigSchema = import_v4.z.object({
+  subscribes: import_v4.z.array(EventTypeSchema).optional(),
+  condition: import_v4.z.string().optional(),
+  emits: import_v4.z.array(EventTypeSchema).optional(),
+  waits: import_v4.z.array(EventWaitSchema).optional(),
+  cancels: import_v4.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v4.z.string().optional()
+});
+
+// src/triggers/types.ts
+var import_v42 = require("zod/v4");
+var CRMDataSchema = import_v42.z.object({
+  model: import_v42.z.string(),
+  instanceId: import_v42.z.string(),
+  data: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown())
+});
+var SenderContextSchema = import_v42.z.object({
+  kind: ParticipantKindSchema,
+  displayName: import_v42.z.string().optional(),
+  crm: CRMDataSchema.optional()
+});
+var ThreadContextItemSchema = import_v42.z.object({
+  handle: import_v42.z.string(),
+  model: import_v42.z.string(),
+  instanceId: import_v42.z.string(),
+  data: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional()
+});
+var ParticipantContextSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  kind: ParticipantKindSchema,
+  displayName: import_v42.z.string().optional(),
+  contactId: import_v42.z.string().optional(),
+  memberId: import_v42.z.string().optional(),
+  agentId: import_v42.z.string().optional(),
+  workflowId: import_v42.z.string().optional()
+});
+var TriggerContextSchema = import_v42.z.object({
+  // The event that triggered this
+  event: import_v42.z.object({
+    type: EventTypeSchema,
+    payload: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()),
+    participant: ParticipantContextSchema.optional()
+  }),
+  // Thread information
+  thread: import_v42.z.object({
+    id: import_v42.z.string(),
+    title: import_v42.z.string().optional(),
+    status: import_v42.z.string().optional(),
+    sender: SenderContextSchema.optional(),
+    context: import_v42.z.record(import_v42.z.string(), CRMDataSchema).optional(),
+    participants: import_v42.z.array(ParticipantContextSchema).optional()
+  }),
+  // Workplace info
+  workplace: import_v42.z.object({
+    id: import_v42.z.string(),
+    name: import_v42.z.string().optional(),
+    settings: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional()
+  })
+});
+var InputMappingSchema = import_v42.z.record(import_v42.z.string(), import_v42.z.string());
+var EventConditionsSchema = import_v42.z.record(import_v42.z.string(), import_v42.z.string());
+var TriggerConfigSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  workflowId: import_v42.z.string(),
+  workflowVersionId: import_v42.z.string().optional(),
+  workplaceId: import_v42.z.string(),
+  handle: import_v42.z.string(),
+  // Input mappings: how to resolve workflow inputs from thread context
+  inputMappings: InputMappingSchema.optional(),
+  // Event conditions: additional workplace-specific conditions
+  eventConditions: EventConditionsSchema.optional(),
+  // Workplace-specific config overrides
+  config: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional(),
+  // Trigger type and status
+  type: import_v42.z.string().optional(),
+  isEnabled: import_v42.z.boolean().optional()
+});
+var ResolvedTriggerSchema = import_v42.z.object({
+  trigger: TriggerConfigSchema,
+  workflow: import_v42.z.object({
+    id: import_v42.z.string(),
+    handle: import_v42.z.string(),
+    name: import_v42.z.string().optional(),
+    inputs: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional(),
+    events: import_v42.z.object({
+      subscribes: import_v42.z.array(EventTypeSchema).optional(),
+      condition: import_v42.z.string().optional()
+    }).optional()
+  }),
+  inputs: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()),
+  context: TriggerContextSchema
+});
+var WorkflowInputDefinitionSchema = import_v42.z.object({
+  type: import_v42.z.string(),
+  required: import_v42.z.boolean().optional(),
+  description: import_v42.z.string().optional(),
+  default: import_v42.z.unknown().optional()
+});
+var WorkflowInputSchemaSchema = import_v42.z.record(import_v42.z.string(), WorkflowInputDefinitionSchema);
+
+// src/workflows/types.ts
+var WorkflowInputSchema = import_v43.z.object({
+  type: import_v43.z.string(),
+  required: import_v43.z.boolean().optional().default(false),
+  description: import_v43.z.string().optional(),
+  default: import_v43.z.unknown().optional()
+});
+var WorkflowStepInputSchema = import_v43.z.union([import_v43.z.string(), import_v43.z.number(), import_v43.z.boolean(), import_v43.z.record(import_v43.z.string(), import_v43.z.unknown())]);
+var WorkflowStepSchema = import_v43.z.object({
+  // Service and command
+  service: import_v43.z.string(),
+  cmd: import_v43.z.string(),
+  // Dependencies
+  needs: import_v43.z.array(import_v43.z.string()).optional(),
+  // Inputs (Liquid templates supported)
+  inputs: import_v43.z.record(import_v43.z.string(), WorkflowStepInputSchema).optional(),
+  // Conditional execution
+  condition: import_v43.z.string().optional(),
+  // Retry configuration
+  retry: import_v43.z.object({
+    attempts: import_v43.z.number().optional(),
+    backoff: import_v43.z.enum(["linear", "exponential"]).optional()
+  }).optional(),
+  // Timeout
+  timeout: import_v43.z.string().optional()
+});
+var WorkflowRuntimeSchema = import_v43.z.object({
+  durable: import_v43.z.boolean().optional().default(true),
+  timeout: import_v43.z.string().optional(),
+  retry: import_v43.z.object({
+    attempts: import_v43.z.number().optional(),
+    backoff: import_v43.z.enum(["linear", "exponential"]).optional()
+  }).optional()
+});
+var WorkflowYAMLSchema = import_v43.z.object({
+  // Schema version
+  $schema: import_v43.z.string().optional(),
+  // Identity
+  handle: import_v43.z.string(),
+  name: import_v43.z.string(),
+  version: import_v43.z.string().optional(),
+  description: import_v43.z.string().optional(),
+  // Inputs this workflow needs (portable, declared in YAML)
+  inputs: import_v43.z.record(import_v43.z.string(), WorkflowInputSchema).optional(),
+  // Event subscriptions and conditions
+  events: EventsConfigSchema.optional(),
+  // Deterministic steps
+  steps: import_v43.z.record(import_v43.z.string(), WorkflowStepSchema),
+  // Runtime configuration
+  runtime: WorkflowRuntimeSchema.optional()
+});
+var WorkflowMetadataSchema = import_v43.z.object({
+  handle: import_v43.z.string(),
+  name: import_v43.z.string(),
+  version: import_v43.z.string().optional(),
+  description: import_v43.z.string().optional(),
+  inputs: import_v43.z.record(import_v43.z.string(), WorkflowInputDefinitionSchema).optional(),
+  events: EventsConfigSchema.optional()
+});
+var WorkflowExecutionStatusSchema = import_v43.z.enum([
+  "PENDING",
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "WAITING"
+]);
+var WorkflowExecutionResultSchema = import_v43.z.object({
+  status: WorkflowExecutionStatusSchema,
+  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional(),
+  error: import_v43.z.string().optional(),
+  startedAt: import_v43.z.string().datetime().optional(),
+  completedAt: import_v43.z.string().datetime().optional(),
+  cancelledAt: import_v43.z.string().datetime().optional(),
+  cancelReason: import_v43.z.string().optional()
+});
+function validateWorkflowYAML(workflow) {
+  const result = WorkflowYAMLSchema.safeParse(workflow);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+
+// src/cli/api/workflows.ts
+function hasPlatformWorkflowSteps(rawWorkflow) {
+  if (!rawWorkflow || typeof rawWorkflow !== "object") {
+    return false;
+  }
+  const steps = rawWorkflow.steps;
+  if (!steps || typeof steps !== "object") {
+    return false;
+  }
+  return Object.values(steps).some(
+    (step) => step && typeof step === "object" && typeof step.type === "string"
+  );
+}
+function validateWorkflowContent(yamlContent) {
+  let rawWorkflow;
+  try {
+    rawWorkflow = (0, import_yaml.parse)(yamlContent);
+  } catch (err) {
+    throw new Error(`Failed to parse YAML: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const validation = validateWorkflowYAML(rawWorkflow);
+  if (!validation.success) {
+    if (!hasPlatformWorkflowSteps(rawWorkflow)) {
+      const errorMessages = validation.error.issues.map((e) => `  - ${String(e.path.join(".")) || "(root)"}: ${e.message}`).join("\n");
+      throw new Error(`Workflow validation failed:
+${errorMessages}`);
+    }
+  }
+  return { content: yamlContent };
+}
+async function listWorkflows(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: { workplaceId: workplaceToken.workplaceId }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list workflows");
+  }
+  return result.workflows;
+}
+async function getWorkflow(ctx, workplace, handle) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: { workplaceId: workplaceToken.workplaceId, handle }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to get workflow");
+  }
+  return result.workflow;
+}
+async function listWorkflowVersions(ctx, workplace, handle) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      action: "versions"
+    }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list versions");
+  }
+  return result.workflow.versions ?? [];
+}
+async function validateWorkflow(ctx, workplace, yamlContent) {
+  validateWorkflowContent(yamlContent);
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "validate",
+    workplaceId: workplaceToken.workplaceId,
+    yamlContent
+  });
+}
+async function deployWorkflow(ctx, workplace, yamlContent, options = {}) {
+  validateWorkflowContent(yamlContent);
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "deploy",
+    workplaceId: workplaceToken.workplaceId,
+    yamlContent,
+    publish: options.publish ?? true,
+    versionLabel: options.versionLabel
+  });
+}
+async function publishWorkflow(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "publish",
+    workplaceId: workplaceToken.workplaceId,
+    handle,
+    version
+  });
+}
+async function pullWorkflow(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      action: "pull",
+      version: version !== void 0 ? String(version) : void 0
+    }
+  });
+}
+async function getWorkflowSchema(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflow-schema", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      version: version !== void 0 ? String(version) : void 0
+    }
+  });
+}
+async function runWorkflow(ctx, workplace, handle, options = {}) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows/run", {
+    workplaceId: workplaceToken.workplaceId,
+    handle,
+    version: options.version,
+    inputs: options.inputs ?? {}
+  });
+}
+async function getWorkflowRun(ctx, workplace, workflowRunId) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows/run", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      workflowRunId
+    }
+  });
+}
+var workflows = {
+  list: listWorkflows,
+  get: getWorkflow,
+  versions: listWorkflowVersions,
+  validate: validateWorkflow,
+  validateLocal: validateWorkflowContent,
+  deploy: deployWorkflow,
+  publish: publishWorkflow,
+  pull: pullWorkflow,
+  schema: getWorkflowSchema,
+  run: runWorkflow,
+  getRun: getWorkflowRun
+};
+
+// src/cli/api/apps.ts
+async function linkApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/link", {
+    appHandle: input.appHandle,
+    workplaceSubdomain: input.workplaceSubdomain
+  });
+}
+async function registerEndpoint(ctx, input) {
+  return callCliApi(cliApi(ctx), "/register-endpoint", {
+    appVersionId: input.appVersionId,
+    invokeEndpoint: input.invokeEndpoint,
+    config: input.config
+  });
+}
+async function unregisterEndpoint(ctx, input) {
+  return callCliApi(cliApi(ctx), "/unregister-endpoint", {
+    appVersionId: input.appVersionId
+  });
+}
+async function heartbeat(ctx, input) {
+  return callCliApi(cliApi(ctx), "/heartbeat", {
+    appVersionId: input.appVersionId,
+    config: input.config
+  });
+}
+async function installApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/install", {
+    appVersionId: input.appVersionId,
+    env: input.env
+  });
+}
+async function uninstallApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/uninstall", {
+    appInstallationId: input.appInstallationId,
+    deleteFields: input.deleteFields
+  });
+}
+async function getInstallation(ctx, input) {
+  return callCliApi(cliApi(ctx), "/installation", {
+    appVersionId: input.appVersionId
+  });
+}
+async function syncResources(ctx, input) {
+  return callCliApi(cliApi(ctx), "/sync-resources", {
+    appVersionId: input.appVersionId,
+    workplaceSubdomain: input.workplaceSubdomain,
+    config: input.config
+  });
+}
+async function listTools(ctx, input) {
+  return callCliApi(cliApi(ctx), "/tools", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: input.workplaceId,
+      name: input.name,
+      toolId: input.toolId,
+      kind: input.kind
+    }
+  });
+}
+async function invokeTool(ctx, input) {
+  return callCliApi(cliApi(ctx), "/invoke-tool", {
+    appInstallationId: input.appInstallationId,
+    toolName: input.toolName,
+    args: input.args ?? {},
+    timeout: input.timeout
+  });
+}
+var apps = {
+  link: linkApp,
+  registerEndpoint,
+  unregisterEndpoint,
+  heartbeat,
+  install: installApp,
+  uninstall: uninstallApp,
+  installation: getInstallation,
+  syncResources,
+  listTools,
+  invokeTool
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  approveMigration,
+  apps,
+  crm,
+  deployWorkflow,
+  diffSchema,
+  getInstallation,
+  getWorkflow,
+  getWorkflowRun,
+  getWorkflowSchema,
+  getWorkplaceToken,
+  heartbeat,
+  installApp,
+  invokeTool,
+  linkApp,
+  listModels,
+  listTools,
+  listWorkflowVersions,
+  listWorkflows,
+  listWorkplaces,
+  publishWorkflow,
+  pullSchema,
+  pullWorkflow,
+  pushSchema,
+  registerEndpoint,
+  runWorkflow,
+  syncResources,
+  uninstallApp,
+  unregisterEndpoint,
+  validateWorkflow,
+  validateWorkflowContent,
+  workflows,
+  workplaces
+});