@sentio/cli 3.5.1-rc.3 → 3.6.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/cli",
-  "version": "3.5.1-rc.3",
+  "version": "3.6.0-rc.2",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/commands/dashboard.ts

@@ -7,6 +7,7 @@ import {
   createApiContext,
   handleCommandError,
   loadJsonInput,
+  postApiJson,
   resolveProjectRef,
   unwrapApiResult
 } from '../api.js'
@@ -30,6 +31,12 @@ interface DashboardImportOptions extends DashboardOptions {
   overrideLayouts?: boolean
 }
 
+interface DashboardCreateOptions extends DashboardOptions {
+  title?: string
+  file?: string
+  stdin?: boolean
+}
+
 interface AddPanelOptions extends DashboardOptions {
   panelName?: string
   type?: string
@@ -48,6 +55,7 @@ interface AddPanelOptions extends DashboardOptions {
 export function createDashboardCommand() {
   const dashboardCommand = new Command('dashboard').description('Manage Sentio dashboards')
   dashboardCommand.addCommand(createDashboardListCommand())
+  dashboardCommand.addCommand(createDashboardCreateCommand())
   dashboardCommand.addCommand(createDashboardExportCommand())
   dashboardCommand.addCommand(createDashboardImportCommand())
   dashboardCommand.addCommand(createDashboardAddPanelCommand())
@@ -68,6 +76,23 @@ function createDashboardListCommand() {
     })
 }
 
+function createDashboardCreateCommand() {
+  return withOutputOptions(
+    withSharedProjectOptions(withAuthOptions(new Command('create').description('Create a dashboard for a project')))
+  )
+    .showHelpAfterError()
+    .requiredOption('--title <name>', 'Dashboard title')
+    .option('--file <path>', 'Read initial dashboard JSON or YAML from file')
+    .option('--stdin', 'Read initial dashboard JSON or YAML from stdin')
+    .action(async (options, command) => {
+      try {
+        await runDashboardCreate(options)
+      } catch (error) {
+        handleDashboardCommandError(error, command)
+      }
+    })
+}
+
 function createDashboardExportCommand() {
   return withOutputOptions(
     withSharedProjectOptions(
@@ -197,6 +222,18 @@ async function runDashboardList(options: DashboardOptions) {
   printOutput(options, data)
 }
 
+async function runDashboardCreate(options: DashboardCreateOptions) {
+  const context = createApiContext(options)
+  const project = await resolveProjectRef(options, context, { ownerSlug: true })
+  const body = buildDashboardCreateBody(options, project)
+  const data = await postApiJson<{ dashboard?: Record<string, unknown> }>('/v1/dashboards', context, body)
+
+  printOutput(options, {
+    message: `Dashboard "${options.title}" created`,
+    dashboard: data.dashboard ?? data
+  })
+}
+
 async function runDashboardExport(dashboardId: string, options: DashboardOptions) {
   const context = createApiContext(options)
   const response = await WebService.exportDashboard({
@@ -229,6 +266,47 @@ async function runDashboardImport(dashboardId: string, options: DashboardImportO
   printOutput(options, { message: `Dashboard imported into ${dashboardId}`, dashboard: data.dashboard })
 }
 
+function buildDashboardCreateBody(options: DashboardCreateOptions, project: { owner: string; slug: string }) {
+  const input = loadJsonInput(options)
+  const initialDashboard = normalizeDashboardInit(input)
+
+  return {
+    name: options.title,
+    projectOwner: project.owner,
+    projectSlug: project.slug,
+    ...initialDashboard
+  }
+}
+
+function normalizeDashboardInit(input: unknown) {
+  if (input === undefined) {
+    return {
+      panels: {},
+      layouts: {
+        responsiveLayouts: {
+          lg: { layouts: [] }
+        }
+      }
+    }
+  }
+
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new CliError('Dashboard initialization data must be a JSON or YAML object.')
+  }
+
+  const dashboard = input as Record<string, unknown>
+  return {
+    panels: isRecord(dashboard.panels) ? dashboard.panels : {},
+    layouts: isRecord(dashboard.layouts)
+      ? dashboard.layouts
+      : {
+          responsiveLayouts: {
+            lg: { layouts: [] }
+          }
+        }
+  }
+}
+
 async function runDashboardAddPanel(dashboardId: string, options: AddPanelOptions) {
   const context = createApiContext(options)
 
@@ -378,6 +456,10 @@ function collectOption(value: string, previous: string[] = []) {
   return previous
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
 function withAuthOptions<T extends Command<any, any, any>>(command: T) {
   return command
     .option('--host <host>', 'Override Sentio host')
@@ -404,6 +486,10 @@ function handleDashboardCommandError(error: unknown, command?: Command) {
       error.message.startsWith('Invalid project ') ||
       error.message.startsWith('Dashboard ') ||
       error.message.startsWith('Provide --file or --stdin') ||
+      error.message.startsWith('Use either --file or --stdin') ||
+      error.message.startsWith('Expected JSON or YAML') ||
+      error.message.startsWith('Invalid JSON or YAML') ||
+      error.message.startsWith('Dashboard initialization data') ||
       error.message.startsWith('Provide exactly one data source') ||
       error.message.startsWith('Use exactly one of --sql') ||
       error.message.startsWith('Invalid chart type') ||

package/src/commands/processor.ts

@@ -337,7 +337,7 @@ async function runProcessorResume(processorId: string | undefined, options: Proc
   })
 }
 
-async function runProcessorStop(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
+export async function runProcessorStop(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
   const resolvedProcessorId = await resolveAndConfirmProcessor('stop', processorId, options)
   if (!resolvedProcessorId) return
   const context = createApiContext(options)

package/src/commands/stop-processor.ts

@@ -0,0 +1,63 @@
+import { Command } from '@commander-js/extra-typings'
+import chalk from 'chalk'
+import { handleCommandError } from '../api.js'
+import { confirm } from './upload.js'
+import { runProcessorStop } from './processor.js'
+import {
+  getSentioNetworkConfig,
+  resolveNetworkAddresses,
+  getWalletFromPrivateKey,
+  requirePrivateKey,
+  stopProcessorOnChain
+} from '../network.js'
+
+export function createStopProcessorCommand() {
+  return new Command('stop')
+    .description('Stop a processor. Uses Sentio Network contract when --sentio-network is specified.')
+    .argument('<processorId>', 'ID of the processor to stop')
+    .option('--sentio-network <network>', 'Stop via Sentio Network contract (only "testnet" supported)')
+    .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')
+    .option('--project <owner/slug>', 'Sentio project in <owner>/<slug> format')
+    .option('--owner <owner>', 'Sentio project owner')
+    .option('--name <name>', 'Sentio project name')
+    .option('-y, --yes', 'Bypass confirmation')
+    .showHelpAfterError()
+    .action(async (processorId, options) => {
+      try {
+        if (options.sentioNetwork) {
+          await runStopProcessorOnChain(processorId, options)
+        } else {
+          await runProcessorStop(processorId, options)
+        }
+      } catch (error) {
+        handleCommandError(error)
+      }
+    })
+}
+
+async function runStopProcessorOnChain(processorId: string, options: { sentioNetwork?: string; yes?: boolean }) {
+  const network = options.sentioNetwork!
+  const networkConfig = getSentioNetworkConfig(network)
+
+  const privateKey = requirePrivateKey()
+  const wallet = getWalletFromPrivateKey(privateKey)
+
+  console.log(chalk.blue(`Wallet address: ${wallet.address}`))
+  console.log(chalk.blue('Resolving contract addresses from AddressBook...'))
+  const addresses = await resolveNetworkAddresses(networkConfig)
+
+  if (!options.yes) {
+    const confirmed = await confirm(`Stop processor "${processorId}" on Sentio Network ${network}?`)
+    if (!confirmed) {
+      console.log('Stop cancelled.')
+      return
+    }
+  }
+
+  await stopProcessorOnChain(networkConfig, addresses, wallet, processorId)
+
+  console.log()
+  console.log(chalk.green(`Processor "${processorId}" stopped on Sentio Network ${network}.`))
+}

package/src/commands/upload.ts

@@ -13,6 +13,21 @@ import readline from 'readline'
 import JSZip from 'jszip'
 import { UserInfo } from '../../../protos/lib/service/common/protos/common.js'
 import { CommandOptionsType } from './types.js'
+import {
+  getSentioNetworkConfig,
+  resolveNetworkAddresses,
+  getWalletFromPrivateKey,
+  requirePrivateKey,
+  checkSTBalance,
+  checkBillingBalance,
+  uploadToIPFS,
+  createProcessorOnChain,
+  startProcessorOnChain,
+  stopProcessorOnChain,
+  confirmNoPlatformUpload,
+  getProcessorOnChain,
+  deleteProcessorOnChain
+} from '../network.js'
 import { Auth, DefaultBatchUploader, FileType, IPFSBatchUploader, WalrusBatchUploader } from '../uploader.js'
 export { type Auth } from '../uploader.js'
 
@@ -56,16 +71,164 @@ export function createUploadCommand() {
       '--required-chain-id <chain_id...>',
       '(Optional) Specify chain IDs required for the Sentio network. This option is only available when --sentio-network is used. If omitted, all chain IDs from the project configuration (contracts or network overrides) will be used.'
     )
+    .option(
+      '--no-platform',
+      'Upload processor directly to Sentio Network without platform support. Requires $PRIVATE_KEY env var. Only testnet is supported.'
+    )
+    .option(
+      '--ipfs-put-url <url>',
+      'IPFS upload endpoint (used with --no-platform)',
+      'https://api.sentio.xyz/v1/ipfs/add'
+    )
     .action(async (options, command) => {
       const processorConfig = loadProcessorConfig(options.path)
       overrideConfigWithOptions(processorConfig, options)
       if (options.path) {
         process.chdir(options.path)
       }
-      await runUploadInternal(processorConfig, options, command)
+      if (options.platform === false) {
+        await runNoPlatformUpload(processorConfig, options)
+      } else {
+        await runUploadInternal(processorConfig, options, command)
+      }
     })
 }
 
+async function runNoPlatformUpload(
+  processorConfig: YamlProjectConfig,
+  options: CommandOptionsType<typeof createUploadCommand>
+) {
+  // Determine network - default to testnet for --no-platform
+  const network = options.sentioNetwork || 'testnet'
+  const networkConfig = getSentioNetworkConfig(network)
+
+  // Step 1: Require PRIVATE_KEY
+  const privateKey = requirePrivateKey()
+  const wallet = getWalletFromPrivateKey(privateKey)
+  const walletAddress = wallet.address
+
+  // Step 2: Resolve contract addresses via AddressBook
+  console.log(chalk.blue('Resolving contract addresses from AddressBook...'))
+  const addresses = await resolveNetworkAddresses(networkConfig)
+
+  // Step 3: Check ST balance and Billing balance, then confirm
+  const [stBalance, billingBalance] = await Promise.all([
+    checkSTBalance(networkConfig, addresses, walletAddress),
+    checkBillingBalance(networkConfig, addresses, walletAddress)
+  ])
+  const confirmed = await confirmNoPlatformUpload(walletAddress, stBalance, billingBalance, addresses, networkConfig)
+  if (!confirmed) {
+    console.log('Upload cancelled.')
+    process.exit(0)
+  }
+
+  // Step 4: Build processor
+  if (!options.skipBuild) {
+    await buildProcessor(false, options)
+  }
+
+  const processorFile = path.join(process.cwd(), 'dist/lib.js')
+  if (!fs.existsSync(processorFile)) {
+    console.error(chalk.red('File not found:', processorFile, "- don't use --skip-build"))
+    process.exit(1)
+  }
+
+  const codeBuffer = fs.readFileSync(processorFile)
+  const stat = fs.statSync(processorFile)
+  console.log('Packed processor file size', Math.floor(stat.size / 1024) + 'K, last modified', stat.mtime)
+
+  // Step 5: Upload to IPFS
+  const ipfsPutUrl = options.ipfsPutUrl || 'https://api.sentio.xyz/v1/ipfs/add'
+  console.log(chalk.blue(`Uploading processor to IPFS (${ipfsPutUrl})...`))
+  const cid = await uploadToIPFS(codeBuffer, ipfsPutUrl)
+  console.log(chalk.green(`IPFS upload complete.`))
+  console.log('\t', chalk.blue('CID:'), cid)
+
+  // Step 6: Collect required chain IDs
+  let requiredChainIds = options.requiredChainId || processorConfig.requiredChainIds || []
+  if (requiredChainIds.length === 0) {
+    const chainIds = new Set<string>()
+    if (processorConfig.contracts) {
+      for (const contract of processorConfig.contracts) {
+        chainIds.add(String(contract.chain))
+      }
+    }
+    if (processorConfig.networkOverrides) {
+      for (const override of processorConfig.networkOverrides) {
+        chainIds.add(String(override.chain))
+      }
+    }
+    requiredChainIds = Array.from(chainIds)
+  }
+  if (requiredChainIds.length === 0) {
+    console.error(
+      chalk.red(
+        'Error: No chain IDs found. Specify --required-chain-id or define contracts/networkOverrides in sentio.yaml.'
+      )
+    )
+    process.exit(1)
+  }
+
+  // Step 7: Derive processor ID from project name
+  let processorId = processorConfig.project.replace('/', '_')
+  const sdkVersion = getSdkVersion() || 'unknown'
+
+  // Step 7.5: Check if processor already exists on-chain
+  console.log(chalk.blue('Checking if processor already exists on-chain...'))
+  const existingProcessor = await getProcessorOnChain(networkConfig, addresses, processorId)
+
+  if (existingProcessor) {
+    const existingOwner = existingProcessor.owner.toLowerCase()
+    const currentWallet = wallet.address.toLowerCase()
+
+    if (existingOwner === currentWallet) {
+      // Same owner — prompt to replace
+      console.log(chalk.yellow(`Processor "${processorId}" already exists (owned by you).`))
+      const shouldReplace = await confirm(`Replace existing processor "${processorId}"?`)
+      if (!shouldReplace) {
+        console.log('Upload cancelled.')
+        process.exit(0)
+      }
+      // Stop and delete existing processor before re-creating
+      await stopProcessorOnChain(networkConfig, addresses, wallet, processorId)
+      await deleteProcessorOnChain(networkConfig, addresses, wallet, processorId)
+    } else {
+      // Different owner — prompt to rename
+      console.log(
+        chalk.yellow(
+          `Processor "${processorId}" already exists and is owned by ${existingProcessor.owner} (not your wallet ${wallet.address}).`
+        )
+      )
+      const randomSuffix = Math.random().toString(36).substring(2, 8)
+      const defaultNewId = `${processorId}-${randomSuffix}`
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+      const newId: string = await new Promise((resolve) =>
+        rl.question(`Enter a new processor ID [${defaultNewId}]: `, (answer) => {
+          rl.close()
+          resolve(answer.trim() || defaultNewId)
+        })
+      )
+      processorId = newId
+      console.log(chalk.blue(`Using processor ID: ${processorId}`))
+    }
+  }
+
+  // Step 8: Create processor on-chain
+  await createProcessorOnChain(networkConfig, addresses, wallet, processorId, cid, requiredChainIds, sdkVersion)
+
+  // Step 9: Start processor on-chain
+  await startProcessorOnChain(networkConfig, addresses, wallet, processorId)
+
+  console.log()
+  console.log(chalk.green('=== Upload Complete ==='))
+  console.log('\t', chalk.blue('Processor ID:'), processorId)
+  console.log('\t', chalk.blue('IPFS CID:'), cid)
+  console.log('\t', chalk.blue('Network:'), network)
+  const codeHash = createHash('sha256').update(codeBuffer).digest('hex')
+  console.log('\t', chalk.blue('sha256:'), codeHash)
+}
+
 function parseCheckpoints(
   checkpoints: string[] | undefined,
   continueFrom: number | undefined,

package/src/index.ts

@@ -19,6 +19,7 @@ import { createPriceCommand } from './commands/price.js'
 import { createSimulationCommand } from './commands/simulation.js'
 import { createEndpointCommand } from './commands/endpoint.js'
 import { createDashboardCommand } from './commands/dashboard.js'
+import { createStopProcessorCommand } from './commands/stop-processor.js'
 import { enableApiDebug } from './api.js'
 import { printVersions } from './utils.js'
 
@@ -52,5 +53,6 @@ program.addCommand(createPriceCommand())
 program.addCommand(createSimulationCommand())
 program.addCommand(createEndpointCommand())
 program.addCommand(createDashboardCommand())
+program.addCommand(createStopProcessorCommand())
 
 program.parse()