@sentio/cli 3.4.1 → 3.5.0-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,10 @@ function createProcessorCommand() {
   processorCommand.addCommand(createProcessorStatusCommand());
   processorCommand.addCommand(createProcessorSourceCommand());
   processorCommand.addCommand(createProcessorActivatePendingCommand());
+  processorCommand.addCommand(createProcessorPauseCommand());
+  processorCommand.addCommand(createProcessorResumeCommand());
+  processorCommand.addCommand(createProcessorStopCommand());
+  processorCommand.addCommand(createProcessorLogsCommand());
   return processorCommand;
 }
 function createProcessorStatusCommand() {
@@ -151942,7 +151971,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 +151979,50 @@ 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);
+    }
+  });
+}
+function createProcessorLogsCommand() {
+  return withOutputOptions3(
+    withSharedProjectOptions3(withAuthOptions3(new Command("logs").description("View processor logs")))
+  ).showHelpAfterError().argument("[processorId]", "ID of the processor (defaults to active processor)").option("--limit <count>", "Maximum number of log entries to fetch", parseInteger2, 100).option("-f, --follow", "Poll for new log entries continuously").option("--log-type <type>", "Filter by log type (e.g. execution, system)").option("--level <level>", "Filter by log level: DEBUG, INFO, WARNING, ERROR").option("--query <query>", "Free-text filter query").action(async (processorId, options, command) => {
+    try {
+      await runProcessorLogs(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 +152071,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 +152109,168 @@ 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
+  });
+}
+async function resolveProcessorId(processorId, options) {
+  if (processorId) return processorId;
+  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: "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.`
+    );
+  }
+  return asString3(activeProcessor.processorId);
+}
+async function runProcessorLogs(processorId, options) {
+  const resolvedProcessorId = await resolveProcessorId(processorId, options);
+  const context = createApiContext(options);
+  if (options.follow && !options.json && !options.yaml) {
+    await followProcessorLogs(resolvedProcessorId, context, options);
+    return;
+  }
+  const response = await postApiJson(
+    `/api/v1/processors/${resolvedProcessorId}/logs`,
+    context,
+    buildLogsRequestBody(resolvedProcessorId, options)
+  );
+  printOutput3(options, response);
+}
+async function followProcessorLogs(processorId, context, options) {
+  let until;
+  let running = true;
+  const seenIds = /* @__PURE__ */ new Set();
+  process19.on("SIGINT", () => {
+    running = false;
+  });
+  while (running) {
+    try {
+      const body = { ...buildLogsRequestBody(processorId, options), until };
+      const response = await postApiJson(`/api/v1/processors/${processorId}/logs`, context, body);
+      const entries2 = Array.isArray(response.logs) ? response.logs : [];
+      for (const entry of entries2) {
+        const e10 = entry;
+        const id = e10.id ?? "";
+        if (id && seenIds.has(id)) continue;
+        if (id) seenIds.add(id);
+        process19.stdout.write(formatLogEntry(e10) + "\n");
+      }
+      if (response.until) {
+        until = response.until;
+      }
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+}
+function buildLogsRequestBody(processorId, options) {
+  const body = { processorId, limit: options.limit };
+  if (options.logType) {
+    body.logTypeFilters = [options.logType];
+  }
+  if (options.level || options.query) {
+    const parts = [];
+    if (options.level) parts.push(options.level.toUpperCase());
+    if (options.query) parts.push(options.query);
+    body.query = parts.join(" ");
+  }
+  return body;
+}
+function formatLogEntry(entry) {
+  const formattedTime = entry.timestamp ? source_default.gray(entry.timestamp.replace("T", " ").replace("Z", "")) : "";
+  const level = (entry.level ?? "INFO").toUpperCase();
+  const logType = entry.logType ? source_default.gray(`[${entry.logType}]`) : "";
+  const coloredLevel = colorSeverity(level);
+  const message = entry.message ?? "";
+  const chain4 = entry.chainId ? source_default.gray(`(chain=${entry.chainId})`) : "";
+  return [formattedTime, coloredLevel, logType, message, chain4].filter(Boolean).join(" ");
+}
+function colorSeverity(severity) {
+  switch (severity) {
+    case "ERROR":
+      return source_default.red(`[${severity}]`);
+    case "WARNING":
+    case "WARN":
+      return source_default.yellow(`[${severity}]`);
+    case "DEBUG":
+      return source_default.gray(`[${severity}]`);
+    default:
+      return source_default.cyan(`[${severity}]`);
+  }
+}
 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");
 }
@@ -152053,7 +152314,8 @@ function formatOutput2(data) {
       lines.push(`${group.versionState} (${group.processors.length})`);
       for (const processor of group.processors) {
         const version2 = asNumber(processor.version);
-        const statusState = asString3(processor.processorStatus?.state) ?? "UNKNOWN";
+        const processorStatus = processor.processorStatus;
+        const statusState = asString3(processorStatus?.state) ?? "UNKNOWN";
         const uploadedAt = asString3(processor.uploadedAt);
         lines.push(`- v${version2 ?? "?"} status=${statusState}${uploadedAt ? ` uploaded=${uploadedAt}` : ""}`);
         if (asString3(processor.processorId)) {
@@ -152063,9 +152325,17 @@ function formatOutput2(data) {
         for (const stateEntry of states.slice(0, 5)) {
           const state = stateEntry;
           const chainId = asString3(state.chainId) ?? "?";
-          const chainState = asString3(state.status?.state) ?? "UNKNOWN";
+          const stateStatus = state.status;
+          const chainState = asString3(stateStatus?.state) ?? "UNKNOWN";
           const block = asString3(state.processedBlockNumber) ?? "?";
           lines.push(`  chain ${chainId}: ${chainState} block=${block}`);
+          const errorRecord = stateStatus?.errorRecord;
+          const chainError = asString3(errorRecord?.message);
+          if (chainError) {
+            const createdAt = asString3(errorRecord?.createdAt);
+            const prefix = createdAt ? `[${createdAt}] ` : "";
+            lines.push(`  error: ${prefix}${chainError}`);
+          }
         }
         if (states.length > 5) {
           lines.push(`  ... ${states.length - 5} more chains`);
@@ -152090,6 +152360,18 @@ 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)}.`;
+  }
+  if (data && typeof data === "object" && "logs" in data) {
+    const logsData = data;
+    const entries2 = Array.isArray(logsData.logs) ? logsData.logs : [];
+    if (entries2.length === 0) {
+      return "No logs found.";
+    }
+    return entries2.map((entry) => formatLogEntry(entry)).join("\n");
+  }
   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.5.0-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

@@ -1,8 +1,18 @@
 import { ProcessorExtService, ProcessorService } from '@sentio/api'
 import { Command, InvalidArgumentError } from '@commander-js/extra-typings'
+import chalk from 'chalk'
 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
@@ -25,11 +35,23 @@ interface ProcessorSourceOptions extends ProcessorOptions {
   path?: string
 }
 
+interface ProcessorLogsOptions extends ProcessorOptions {
+  limit?: number
+  follow?: boolean
+  logType?: string
+  level?: string
+  query?: string
+}
+
 export function createProcessorCommand() {
   const processorCommand = new Command('processor').description('Manage Sentio processor versions')
   processorCommand.addCommand(createProcessorStatusCommand())
   processorCommand.addCommand(createProcessorSourceCommand())
   processorCommand.addCommand(createProcessorActivatePendingCommand())
+  processorCommand.addCommand(createProcessorPauseCommand())
+  processorCommand.addCommand(createProcessorResumeCommand())
+  processorCommand.addCommand(createProcessorStopCommand())
+  processorCommand.addCommand(createProcessorLogsCommand())
   return processorCommand
 }
 
@@ -71,6 +93,7 @@ function createProcessorActivatePendingCommand() {
     )
   )
     .showHelpAfterError()
+    .option('-y, --yes', 'Bypass confirmation')
     .action(async (options, command) => {
       try {
         await runActivatePending(options)
@@ -80,6 +103,75 @@ 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)
+      }
+    })
+}
+
+function createProcessorLogsCommand() {
+  return withOutputOptions(
+    withSharedProjectOptions(withAuthOptions(new Command('logs').description('View processor logs')))
+  )
+    .showHelpAfterError()
+    .argument('[processorId]', 'ID of the processor (defaults to active processor)')
+    .option('--limit <count>', 'Maximum number of log entries to fetch', parseInteger, 100)
+    .option('-f, --follow', 'Poll for new log entries continuously')
+    .option('--log-type <type>', 'Filter by log type (e.g. execution, system)')
+    .option('--level <level>', 'Filter by log level: DEBUG, INFO, WARNING, ERROR')
+    .option('--query <query>', 'Free-text filter query')
+    .action(async (processorId, options, command) => {
+      try {
+        await runProcessorLogs(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 +219,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 +267,216 @@ 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>)
+  })
+}
+
+async function resolveProcessorId(processorId: string | undefined, options: ProcessorOptions): Promise<string> {
+  if (processorId) return processorId
+  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: '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.`
+    )
+  }
+  return asString(activeProcessor.processorId)!
+}
+
+async function runProcessorLogs(processorId: string | undefined, options: ProcessorLogsOptions) {
+  const resolvedProcessorId = await resolveProcessorId(processorId, options)
+  const context = createApiContext(options)
+
+  if (options.follow && !options.json && !options.yaml) {
+    await followProcessorLogs(resolvedProcessorId, context, options)
+    return
+  }
+
+  const response = await postApiJson<ProcessorLogsResponse>(
+    `/api/v1/processors/${resolvedProcessorId}/logs`,
+    context,
+    buildLogsRequestBody(resolvedProcessorId, options)
+  )
+  printOutput(options, response)
+}
+
+async function followProcessorLogs(
+  processorId: string,
+  context: ReturnType<typeof createApiContext>,
+  options: ProcessorLogsOptions
+) {
+  let until: unknown[] | undefined
+  let running = true
+  const seenIds = new Set<string>()
+
+  process.on('SIGINT', () => {
+    running = false
+  })
+
+  while (running) {
+    try {
+      const body = { ...buildLogsRequestBody(processorId, options), until }
+      const response = await postApiJson<ProcessorLogsResponse>(`/api/v1/processors/${processorId}/logs`, context, body)
+      const entries = Array.isArray(response.logs) ? response.logs : []
+      for (const entry of entries) {
+        const e = entry as ProcessorLog
+        const id = e.id ?? ''
+        if (id && seenIds.has(id)) continue
+        if (id) seenIds.add(id)
+        process.stdout.write(formatLogEntry(e) + '\n')
+      }
+      if (response.until) {
+        until = response.until
+      }
+    } catch {
+      // Ignore transient fetch errors during follow mode
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000))
+  }
+}
+
+function buildLogsRequestBody(processorId: string, options: ProcessorLogsOptions): Record<string, unknown> {
+  const body: Record<string, unknown> = { processorId, limit: options.limit }
+  if (options.logType) {
+    body.logTypeFilters = [options.logType]
+  }
+  if (options.level || options.query) {
+    const parts: string[] = []
+    if (options.level) parts.push(options.level.toUpperCase())
+    if (options.query) parts.push(options.query)
+    body.query = parts.join(' ')
+  }
+  return body
+}
+
+interface ProcessorLog {
+  id?: string
+  message?: string
+  timestamp?: string
+  attributes?: Record<string, unknown>
+  logType?: string
+  level?: string
+  highlightedMessage?: string
+  chainId?: string
+}
+
+interface ProcessorLogsResponse {
+  logs?: ProcessorLog[]
+  until?: unknown[]
+  total?: string
+}
+
+function formatLogEntry(entry: ProcessorLog): string {
+  const formattedTime = entry.timestamp ? chalk.gray(entry.timestamp.replace('T', ' ').replace('Z', '')) : ''
+  const level = (entry.level ?? 'INFO').toUpperCase()
+  const logType = entry.logType ? chalk.gray(`[${entry.logType}]`) : ''
+  const coloredLevel = colorSeverity(level)
+  const message = entry.message ?? ''
+  const chain = entry.chainId ? chalk.gray(`(chain=${entry.chainId})`) : ''
+
+  return [formattedTime, coloredLevel, logType, message, chain].filter(Boolean).join(' ')
+}
+
+function colorSeverity(severity: string): string {
+  switch (severity) {
+    case 'ERROR':
+      return chalk.red(`[${severity}]`)
+    case 'WARNING':
+    case 'WARN':
+      return chalk.yellow(`[${severity}]`)
+    case 'DEBUG':
+      return chalk.gray(`[${severity}]`)
+    default:
+      return chalk.cyan(`[${severity}]`)
+  }
+}
+
 function withAuthOptions<T extends Command<any, any, any>>(command: T) {
   return command
     .option('--host <host>', 'Override Sentio host')
@@ -204,8 +538,8 @@ function formatOutput(data: unknown) {
       lines.push(`${group.versionState} (${group.processors.length})`)
       for (const processor of group.processors) {
         const version = asNumber(processor.version)
-        const statusState =
-          asString((processor.processorStatus as Record<string, unknown> | undefined)?.state) ?? 'UNKNOWN'
+        const processorStatus = processor.processorStatus as Record<string, unknown> | undefined
+        const statusState = asString(processorStatus?.state) ?? 'UNKNOWN'
         const uploadedAt = asString(processor.uploadedAt)
         lines.push(`- v${version ?? '?'} status=${statusState}${uploadedAt ? ` uploaded=${uploadedAt}` : ''}`)
         if (asString(processor.processorId)) {
@@ -215,9 +549,17 @@ function formatOutput(data: unknown) {
         for (const stateEntry of states.slice(0, 5)) {
           const state = stateEntry as Record<string, unknown>
           const chainId = asString(state.chainId) ?? '?'
-          const chainState = asString((state.status as Record<string, unknown> | undefined)?.state) ?? 'UNKNOWN'
+          const stateStatus = state.status as Record<string, unknown> | undefined
+          const chainState = asString(stateStatus?.state) ?? 'UNKNOWN'
           const block = asString(state.processedBlockNumber) ?? '?'
           lines.push(`  chain ${chainId}: ${chainState} block=${block}`)
+          const errorRecord = stateStatus?.errorRecord as Record<string, unknown> | undefined
+          const chainError = asString(errorRecord?.message)
+          if (chainError) {
+            const createdAt = asString(errorRecord?.createdAt)
+            const prefix = createdAt ? `[${createdAt}] ` : ''
+            lines.push(`  error: ${prefix}${chainError}`)
+          }
         }
         if (states.length > 5) {
           lines.push(`  ... ${states.length - 5} more chains`)
@@ -246,6 +588,25 @@ 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)}.`
+  }
+
+  if (data && typeof data === 'object' && 'logs' in (data as Record<string, unknown>)) {
+    const logsData = data as ProcessorLogsResponse
+    const entries = Array.isArray(logsData.logs) ? logsData.logs : []
+    if (entries.length === 0) {
+      return 'No logs found.'
+    }
+    return entries.map((entry) => formatLogEntry(entry)).join('\n')
+  }
+
   return JSON.stringify(data, null, 2)
 }