@sentio/cli 3.4.1 → 3.4.2-rc.1

package/lib/index.js

@@ -150515,6 +150515,31 @@ async function postApiJson(apiPath, context, body, query) {
   }
   return await response.json();
 }
+async function putApiJson(apiPath, context, body, query) {
+  const url5 = getApiUrl(apiPath, context.host);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url5.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const response = await fetch(url5.href, {
+    method: "PUT",
+    headers: {
+      ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+      ...context.headers
+    },
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new CliError(
+      `Sentio API request failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  return await response.json();
+}
 function parseStructuredInput(content, source, filename) {
   if (!content.trim()) {
     throw new CliError(`Expected JSON or YAML in ${source}, but it was empty.`);
@@ -151913,6 +151938,9 @@ function createProcessorCommand() {
   processorCommand.addCommand(createProcessorStatusCommand());
   processorCommand.addCommand(createProcessorSourceCommand());
   processorCommand.addCommand(createProcessorActivatePendingCommand());
+  processorCommand.addCommand(createProcessorPauseCommand());
+  processorCommand.addCommand(createProcessorResumeCommand());
+  processorCommand.addCommand(createProcessorStopCommand());
   return processorCommand;
 }
 function createProcessorStatusCommand() {
@@ -151942,7 +151970,7 @@ function createProcessorActivatePendingCommand() {
     withSharedProjectOptions3(
       withAuthOptions3(new Command("activate-pending").description("Activate the pending version"))
     )
-  ).showHelpAfterError().action(async (options, command) => {
+  ).showHelpAfterError().option("-y, --yes", "Bypass confirmation").action(async (options, command) => {
     try {
       await runActivatePending(options);
     } catch (error) {
@@ -151950,6 +151978,39 @@ function createProcessorActivatePendingCommand() {
     }
   });
 }
+function createProcessorPauseCommand() {
+  return withOutputOptions3(
+    withSharedProjectOptions3(withAuthOptions3(new Command("pause").description("Pause a processor")))
+  ).showHelpAfterError().argument("[processorId]", "ID of the processor").option("--reason <reason>", "Reason for pausing").option("-y, --yes", "Bypass confirmation").action(async (processorId, options, command) => {
+    try {
+      await runProcessorPause(processorId, options);
+    } catch (error) {
+      handleProcessorCommandError(error, command);
+    }
+  });
+}
+function createProcessorResumeCommand() {
+  return withOutputOptions3(
+    withSharedProjectOptions3(withAuthOptions3(new Command("resume").description("Resume a processor")))
+  ).showHelpAfterError().argument("[processorId]", "ID of the processor").option("-y, --yes", "Bypass confirmation").action(async (processorId, options, command) => {
+    try {
+      await runProcessorResume(processorId, options);
+    } catch (error) {
+      handleProcessorCommandError(error, command);
+    }
+  });
+}
+function createProcessorStopCommand() {
+  return withOutputOptions3(
+    withSharedProjectOptions3(withAuthOptions3(new Command("stop").description("Stop a processor")))
+  ).showHelpAfterError().argument("[processorId]", "ID of the processor").option("-y, --yes", "Bypass confirmation").action(async (processorId, options, command) => {
+    try {
+      await runProcessorStop(processorId, options);
+    } catch (error) {
+      handleProcessorCommandError(error, command);
+    }
+  });
+}
 async function runProcessorStatus(options) {
   const context = createApiContext(options);
   const project = await resolveProjectRef(options, context, { ownerSlug: true });
@@ -151998,6 +152059,32 @@ async function runProcessorSource(options) {
 async function runActivatePending(options) {
   const context = createApiContext(options);
   const project = await resolveProjectRef(options, context, { ownerSlug: true });
+  const statusResponse = await import_api5.ProcessorService.getProcessorStatusV2({
+    path: {
+      owner: project.owner,
+      slug: project.slug
+    },
+    query: { version: "ALL" },
+    headers: context.headers
+  });
+  const data = unwrapApiResult(statusResponse);
+  const processors = Array.isArray(data.processors) ? data.processors : [];
+  const activeProcessor = processors.find((p7) => asString3(p7.versionState) === "ACTIVE");
+  const pendingProcessor = processors.find((p7) => asString3(p7.versionState) === "PENDING");
+  if (!pendingProcessor) {
+    throw new CliError(`No pending version found for project ${project.owner}/${project.slug}.`);
+  }
+  if (!options.yes) {
+    let message = `Activate the pending version ${asNumber(pendingProcessor.version)}. Are you sure you want to proceed?`;
+    if (activeProcessor) {
+      message = `Activate the pending version ${asNumber(pendingProcessor.version)} may obsolete the active version ${asNumber(activeProcessor.version)}. Are you sure you want to proceed?`;
+    }
+    const isConfirmed = await confirm(message);
+    if (!isConfirmed) {
+      console.log("Activation cancelled.");
+      return;
+    }
+  }
   const response = await import_api5.ProcessorService.activatePendingVersion({
     path: {
       owner: project.owner,
@@ -152010,6 +152097,73 @@ async function runActivatePending(options) {
     ...unwrapApiResult(response)
   });
 }
+async function resolveAndConfirmProcessor(actionName, processorId, options) {
+  const context = createApiContext(options);
+  let resolvedProcessorId = processorId;
+  let versionToConfirm = "";
+  if (!resolvedProcessorId) {
+    const project = await resolveProjectRef(options, context, { ownerSlug: true });
+    const statusResponse = await import_api5.ProcessorService.getProcessorStatusV2({
+      path: {
+        owner: project.owner,
+        slug: project.slug
+      },
+      query: { version: "ACTIVE" },
+      headers: context.headers
+    });
+    const data = unwrapApiResult(statusResponse);
+    const processors = Array.isArray(data.processors) ? data.processors : [];
+    const activeProcessor = processors.find((p7) => asString3(p7.versionState) === "ACTIVE");
+    if (!activeProcessor || !activeProcessor.processorId) {
+      throw new CliError(
+        `No active processor found for project ${project.owner}/${project.slug}. Please specify a processorId.`
+      );
+    }
+    resolvedProcessorId = asString3(activeProcessor.processorId);
+    versionToConfirm = `version ${asNumber(activeProcessor.version)} of project ${project.owner}/${project.slug}`;
+  } else {
+    versionToConfirm = `processor ${resolvedProcessorId}`;
+  }
+  if (!options.yes) {
+    const isConfirmed = await confirm(`Are you sure you want to ${actionName} ${versionToConfirm}?`);
+    if (!isConfirmed) {
+      console.log(`${actionName.charAt(0).toUpperCase() + actionName.slice(1)} cancelled.`);
+      return void 0;
+    }
+  }
+  return resolvedProcessorId;
+}
+async function runProcessorPause(processorId, options) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor("pause", processorId, options);
+  if (!resolvedProcessorId) return;
+  const context = createApiContext(options);
+  const response = await putApiJson(`/api/v1/processors/${resolvedProcessorId}/pause`, context, {
+    reason: options.reason
+  });
+  printOutput3(options, { processorId: resolvedProcessorId, action: "paused", ...response });
+}
+async function runProcessorResume(processorId, options) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor("resume", processorId, options);
+  if (!resolvedProcessorId) return;
+  const context = createApiContext(options);
+  const response = await putApiJson(`/api/v1/processors/${resolvedProcessorId}/resume`, context);
+  printOutput3(options, {
+    processorId: resolvedProcessorId,
+    action: "resumed",
+    ...response
+  });
+}
+async function runProcessorStop(processorId, options) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor("stop", processorId, options);
+  if (!resolvedProcessorId) return;
+  const context = createApiContext(options);
+  const response = await postApiJson(`/api/v1/processors/stop`, context, { processorId: resolvedProcessorId });
+  printOutput3(options, {
+    processorId: resolvedProcessorId,
+    action: "stopped",
+    ...response
+  });
+}
 function withAuthOptions3(command) {
   return command.option("--host <host>", "Override Sentio host").option("--api-key <key>", "Use an explicit API key instead of saved credentials").option("--token <token>", "Use an explicit bearer token instead of saved credentials");
 }
@@ -152090,6 +152244,10 @@ function formatOutput2(data) {
     const objectData = data;
     return `Pending processor version activated for ${asString3(objectData.project) ?? "<project>"}.`;
   }
+  if (data && typeof data === "object" && "action" in data && "processorId" in data) {
+    const objectData = data;
+    return `Processor ${asString3(objectData.processorId)} successfully ${asString3(objectData.action)}.`;
+  }
   return JSON.stringify(data, null, 2);
 }
 function normalizeVersionSelector(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/cli",
-  "version": "3.4.1",
+  "version": "3.4.2-rc.1",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/api.ts

@@ -420,6 +420,37 @@ export async function postApiJson<T>(
   return (await response.json()) as T
 }
 
+export async function putApiJson<T>(
+  apiPath: string,
+  context: ApiContext,
+  body?: unknown,
+  query?: Record<string, string | number | boolean | undefined>
+): Promise<T> {
+  const url = getApiUrl(apiPath, context.host)
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined) {
+        url.searchParams.set(key, String(value))
+      }
+    }
+  }
+  const response = await fetch(url.href, {
+    method: 'PUT',
+    headers: {
+      ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+      ...context.headers
+    },
+    body: body !== undefined ? JSON.stringify(body) : undefined
+  })
+  if (!response.ok) {
+    const text = await response.text()
+    throw new CliError(
+      `Sentio API request failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ''}`
+    )
+  }
+  return (await response.json()) as T
+}
+
 function parseStructuredInput(content: string, source: string, filename?: string) {
   if (!content.trim()) {
     throw new CliError(`Expected JSON or YAML in ${source}, but it was empty.`)

package/src/commands/processor.ts

@@ -2,7 +2,16 @@ import { ProcessorExtService, ProcessorService } from '@sentio/api'
 import { Command, InvalidArgumentError } from '@commander-js/extra-typings'
 import process from 'process'
 import yaml from 'yaml'
-import { CliError, createApiContext, handleCommandError, resolveProjectRef, unwrapApiResult } from '../api.js'
+import {
+  CliError,
+  createApiContext,
+  handleCommandError,
+  resolveProjectRef,
+  unwrapApiResult,
+  postApiJson,
+  putApiJson
+} from '../api.js'
+import { confirm } from './upload.js'
 
 interface ProcessorOptions {
   host?: string
@@ -30,6 +39,9 @@ export function createProcessorCommand() {
   processorCommand.addCommand(createProcessorStatusCommand())
   processorCommand.addCommand(createProcessorSourceCommand())
   processorCommand.addCommand(createProcessorActivatePendingCommand())
+  processorCommand.addCommand(createProcessorPauseCommand())
+  processorCommand.addCommand(createProcessorResumeCommand())
+  processorCommand.addCommand(createProcessorStopCommand())
   return processorCommand
 }
 
@@ -71,6 +83,7 @@ function createProcessorActivatePendingCommand() {
     )
   )
     .showHelpAfterError()
+    .option('-y, --yes', 'Bypass confirmation')
     .action(async (options, command) => {
       try {
         await runActivatePending(options)
@@ -80,6 +93,55 @@ function createProcessorActivatePendingCommand() {
     })
 }
 
+function createProcessorPauseCommand() {
+  return withOutputOptions(
+    withSharedProjectOptions(withAuthOptions(new Command('pause').description('Pause a processor')))
+  )
+    .showHelpAfterError()
+    .argument('[processorId]', 'ID of the processor')
+    .option('--reason <reason>', 'Reason for pausing')
+    .option('-y, --yes', 'Bypass confirmation')
+    .action(async (processorId, options, command) => {
+      try {
+        await runProcessorPause(processorId, options)
+      } catch (error) {
+        handleProcessorCommandError(error, command)
+      }
+    })
+}
+
+function createProcessorResumeCommand() {
+  return withOutputOptions(
+    withSharedProjectOptions(withAuthOptions(new Command('resume').description('Resume a processor')))
+  )
+    .showHelpAfterError()
+    .argument('[processorId]', 'ID of the processor')
+    .option('-y, --yes', 'Bypass confirmation')
+    .action(async (processorId, options, command) => {
+      try {
+        await runProcessorResume(processorId, options)
+      } catch (error) {
+        handleProcessorCommandError(error, command)
+      }
+    })
+}
+
+function createProcessorStopCommand() {
+  return withOutputOptions(
+    withSharedProjectOptions(withAuthOptions(new Command('stop').description('Stop a processor')))
+  )
+    .showHelpAfterError()
+    .argument('[processorId]', 'ID of the processor')
+    .option('-y, --yes', 'Bypass confirmation')
+    .action(async (processorId, options, command) => {
+      try {
+        await runProcessorStop(processorId, options)
+      } catch (error) {
+        handleProcessorCommandError(error, command)
+      }
+    })
+}
+
 async function runProcessorStatus(options: ProcessorStatusOptions) {
   const context = createApiContext(options)
   const project = await resolveProjectRef(options, context, { ownerSlug: true })
@@ -127,9 +189,41 @@ async function runProcessorSource(options: ProcessorSourceOptions) {
   printOutput(options, data)
 }
 
-async function runActivatePending(options: ProcessorOptions) {
+async function runActivatePending(options: ProcessorOptions & { yes?: boolean }) {
   const context = createApiContext(options)
   const project = await resolveProjectRef(options, context, { ownerSlug: true })
+
+  const statusResponse = await ProcessorService.getProcessorStatusV2({
+    path: {
+      owner: project.owner,
+      slug: project.slug
+    },
+    query: { version: 'ALL' },
+    headers: context.headers
+  })
+  const data = unwrapApiResult(statusResponse)
+  const processors = Array.isArray(data.processors) ? data.processors : []
+
+  const activeProcessor = processors.find((p) => asString(p.versionState) === 'ACTIVE')
+  const pendingProcessor = processors.find((p) => asString(p.versionState) === 'PENDING')
+
+  if (!pendingProcessor) {
+    throw new CliError(`No pending version found for project ${project.owner}/${project.slug}.`)
+  }
+
+  if (!options.yes) {
+    let message = `Activate the pending version ${asNumber(pendingProcessor.version)}. Are you sure you want to proceed?`
+    if (activeProcessor) {
+      message = `Activate the pending version ${asNumber(pendingProcessor.version)} may obsolete the active version ${asNumber(activeProcessor.version)}. Are you sure you want to proceed?`
+    }
+
+    const isConfirmed = await confirm(message)
+    if (!isConfirmed) {
+      console.log('Activation cancelled.')
+      return
+    }
+  }
+
   const response = await ProcessorService.activatePendingVersion({
     path: {
       owner: project.owner,
@@ -143,6 +237,88 @@ async function runActivatePending(options: ProcessorOptions) {
   })
 }
 
+async function resolveAndConfirmProcessor(
+  actionName: string,
+  processorId: string | undefined,
+  options: ProcessorOptions & { yes?: boolean }
+): Promise<string | undefined> {
+  const context = createApiContext(options)
+  let resolvedProcessorId = processorId
+  let versionToConfirm = ''
+
+  if (!resolvedProcessorId) {
+    const project = await resolveProjectRef(options, context, { ownerSlug: true })
+    const statusResponse = await ProcessorService.getProcessorStatusV2({
+      path: {
+        owner: project.owner,
+        slug: project.slug
+      },
+      query: { version: 'ACTIVE' },
+      headers: context.headers
+    })
+    const data = unwrapApiResult(statusResponse)
+    const processors = Array.isArray(data.processors) ? data.processors : []
+    const activeProcessor = processors.find((p) => asString(p.versionState) === 'ACTIVE')
+
+    if (!activeProcessor || !activeProcessor.processorId) {
+      throw new CliError(
+        `No active processor found for project ${project.owner}/${project.slug}. Please specify a processorId.`
+      )
+    }
+    resolvedProcessorId = asString(activeProcessor.processorId)!
+    versionToConfirm = `version ${asNumber(activeProcessor.version)} of project ${project.owner}/${project.slug}`
+  } else {
+    versionToConfirm = `processor ${resolvedProcessorId}`
+  }
+
+  if (!options.yes) {
+    const isConfirmed = await confirm(`Are you sure you want to ${actionName} ${versionToConfirm}?`)
+    if (!isConfirmed) {
+      console.log(`${actionName.charAt(0).toUpperCase() + actionName.slice(1)} cancelled.`)
+      return undefined
+    }
+  }
+
+  return resolvedProcessorId
+}
+
+async function runProcessorPause(
+  processorId: string | undefined,
+  options: ProcessorOptions & { reason?: string; yes?: boolean }
+) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor('pause', processorId, options)
+  if (!resolvedProcessorId) return
+  const context = createApiContext(options)
+  const response = await putApiJson(`/api/v1/processors/${resolvedProcessorId}/pause`, context, {
+    reason: options.reason
+  })
+  printOutput(options, { processorId: resolvedProcessorId, action: 'paused', ...(response as Record<string, unknown>) })
+}
+
+async function runProcessorResume(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor('resume', processorId, options)
+  if (!resolvedProcessorId) return
+  const context = createApiContext(options)
+  const response = await putApiJson(`/api/v1/processors/${resolvedProcessorId}/resume`, context)
+  printOutput(options, {
+    processorId: resolvedProcessorId,
+    action: 'resumed',
+    ...(response as Record<string, unknown>)
+  })
+}
+
+async function runProcessorStop(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
+  const resolvedProcessorId = await resolveAndConfirmProcessor('stop', processorId, options)
+  if (!resolvedProcessorId) return
+  const context = createApiContext(options)
+  const response = await postApiJson(`/api/v1/processors/stop`, context, { processorId: resolvedProcessorId })
+  printOutput(options, {
+    processorId: resolvedProcessorId,
+    action: 'stopped',
+    ...(response as Record<string, unknown>)
+  })
+}
+
 function withAuthOptions<T extends Command<any, any, any>>(command: T) {
   return command
     .option('--host <host>', 'Override Sentio host')
@@ -246,6 +422,16 @@ function formatOutput(data: unknown) {
     return `Pending processor version activated for ${asString(objectData.project) ?? '<project>'}.`
   }
 
+  if (
+    data &&
+    typeof data === 'object' &&
+    'action' in (data as Record<string, unknown>) &&
+    'processorId' in (data as Record<string, unknown>)
+  ) {
+    const objectData = data as Record<string, unknown>
+    return `Processor ${asString(objectData.processorId)} successfully ${asString(objectData.action)}.`
+  }
+
   return JSON.stringify(data, null, 2)
 }