@adobe/aio-cli-plugin-app-storage 1.2.0 → 1.3.0-pre.2026-02-12.sha-6f4504ab

package/src/commands/app/db/index/list.js

@@ -0,0 +1,82 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../../DBBaseCommand.js'
+import { Args } from '@oclif/core'
+import chalk from 'chalk'
+import { isNonEmptyString } from '../../../../utils/inputValidation.js'
+import { prettyJson } from '../../../../utils/output.js'
+
+export class List extends DBBaseCommand {
+  async run () {
+    const { collection } = this.args
+
+    try {
+      this.log(chalk.blue(`Getting indexes from collection '${collection}'...`))
+
+      const client = await this.db.connect()
+      const coll = await client.collection(collection)
+
+      const result = await coll.getIndexes()
+
+      this.debugLogger?.info?.('Indexes retrieved successfully:', result)
+
+      const response = {
+        collection,
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString(),
+        indexes: result
+      }
+
+      this.log(chalk.green('Indexes retrieved successfully'))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Retrieved: ${new Date().toLocaleString()}`))
+      if (result && Array.isArray(result) && result.length > 0) {
+        this.log(chalk.dim(`   Indexes:\n${prettyJson(result)}`))
+      } else {
+        this.log(chalk.dim('   No indexes found for this collection'))
+      }
+
+      return response
+    } catch (error) {
+      this.debugLogger?.error?.('Error getting indexes:', error)
+
+      this.log(chalk.red('Failed to retrieve indexes'))
+      this.log(chalk.dim(`   Collection: ${collection}`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Error: ${error.message}`))
+
+      this.error(`Failed to retrieve indexes from collection '${collection}': ${error.message}`)
+    }
+  }
+}
+
+List.description = 'Get the list of indexes from a collection in the database'
+
+List.examples = [
+  '$ aio app db index list users',
+  '$ aio app db index list products --json',
+  '$ aio app db idx list orders'
+]
+
+List.args = {
+  collection: Args.string({
+    name: 'collection',
+    description: 'The name of the collection to retrieve indexes from',
+    required: true,
+    parse: input => isNonEmptyString(input, 'Collection name')
+  })
+}
+
+List.flags = DBBaseCommand.flags
+
+List.aliases = ['app:db:idx:list']

package/src/commands/app/db/ping.js

@@ -0,0 +1,77 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../DBBaseCommand.js'
+import chalk from 'chalk'
+
+export class Ping extends DBBaseCommand {
+  async run () {
+    try {
+      this.log(chalk.blue('Testing database connectivity...'))
+
+      const startTime = Date.now()
+      const pingResult = await this.db.ping()
+      const endTime = Date.now()
+      const responseTime = endTime - startTime
+
+      this.debugLogger?.info?.(`Database ping completed in ${responseTime}ms:`, pingResult)
+
+      this.log(chalk.green('Database connection successful'))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Response time: ${responseTime}ms`))
+
+      if (typeof pingResult === 'string') {
+        this.log(chalk.dim(`   Response: ${pingResult}`))
+      }
+
+      const result = {
+        status: 'success',
+        namespace: this.rtNamespace,
+        responseTime,
+        response: pingResult,
+        timestamp: new Date().toISOString()
+      }
+
+      this.log(chalk.dim('Database is ready for operations'))
+
+      return result
+    } catch (error) {
+      this.debugLogger?.error?.('Ping command error:', error)
+
+      this.log(chalk.red('Database connection failed'))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Error: ${error.message}`))
+
+      const result = {
+        status: 'failed',
+        namespace: this.rtNamespace,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }
+
+      return result
+    }
+  }
+}
+
+Ping.description = 'Test connectivity to your App Builder database'
+
+Ping.examples = [
+  '$ aio app db ping',
+  '$ aio app db ping --json'
+]
+
+Ping.flags = {
+  ...DBBaseCommand.flags
+}
+
+Ping.args = {}

package/src/commands/app/db/provision.js

@@ -0,0 +1,190 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../DBBaseCommand.js'
+import chalk from 'chalk'
+import { DB_STATUS } from '../../../constants/db.js'
+import { Flags } from '@oclif/core'
+
+export class Provision extends DBBaseCommand {
+  async run () {
+    const region = this.db.region
+
+    try {
+      // First check if database is already provisioned
+      this.log(chalk.blue('Checking current provisioning status...'))
+
+      let provisionStatusResponse
+      try {
+        provisionStatusResponse = await this.db.provisionStatus()
+        this.debugLogger?.info?.('Provision status:', provisionStatusResponse)
+      } catch (error) {
+        this.debugLogger?.info?.('No existing provisioning status found:', error.message)
+        provisionStatusResponse = null
+      }
+
+      if (provisionStatusResponse) {
+        const currentStatus = provisionStatusResponse.status.toUpperCase()
+        const statusRegion = provisionStatusResponse.region
+
+        if (currentStatus === DB_STATUS.PROVISIONED) {
+          this.log(chalk.green('Database is already provisioned and ready for use'))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Region: ${statusRegion}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+
+          return {
+            status: 'already_provisioned',
+            namespace: this.rtNamespace,
+            details: provisionStatusResponse
+          }
+        } else if (currentStatus === DB_STATUS.REQUESTED) {
+          this.log(chalk.yellow('Database provisioning request has been submitted and is pending'))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Region: ${statusRegion}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+          this.log(chalk.dim('\nUse "aio app db status --watch" to monitor progress'))
+
+          return {
+            status: 'in_progress',
+            namespace: this.rtNamespace,
+            details: provisionStatusResponse
+          }
+        } else if (currentStatus === DB_STATUS.PROCESSING) {
+          this.log(chalk.yellow('Database is currently being provisioned'))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Region: ${statusRegion}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+          this.log(chalk.dim('\nUse "aio app db status --watch" to monitor progress'))
+          this.log(chalk.red('If provisioning takes unusually long, please contact the App Builder team'))
+
+          return {
+            status: 'in_progress',
+            namespace: this.rtNamespace,
+            details: provisionStatusResponse
+          }
+        } else if (currentStatus === DB_STATUS.FAILED) {
+          this.log(chalk.red('Previous database provisioning failed'))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+          this.log(chalk.yellow('\nAttempting to provision again...'))
+          this.log(chalk.red('If the problem persists, please contact the App Builder team'))
+        } else if (currentStatus === DB_STATUS.REJECTED) {
+          this.log(chalk.red('Previous database provisioning request was rejected'))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+          this.log(chalk.yellow('\nAttempting to provision again...'))
+          this.log(chalk.red('If the problem persists, please contact the App Builder team for assistance'))
+        } else if (currentStatus !== DB_STATUS.NOT_PROVISIONED) {
+          this.log(chalk.yellow(`Database status is '${currentStatus}' - attempting to provision...`))
+          this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+          this.log(chalk.dim(`   Status: ${currentStatus}`))
+          this.log(chalk.red('If you encounter issues, please contact the App Builder team'))
+        }
+      }
+
+      // Create a new database if not yet provisioned
+      this.warn('Database provisioning will create new database resources')
+
+      // Skip confirmation prompt if --yes flag is used
+      if (!this.flags.yes) {
+        // eslint-disable-next-line node/no-unsupported-features/es-syntax
+        const { confirm } = await import('@inquirer/prompts')
+
+        const confirmed = await confirm({
+          message: `Provision database for namespace '${this.rtNamespace}'?`,
+          default: false
+        })
+
+        if (!confirmed) {
+          this.log('Database provisioning cancelled')
+          return { status: 'cancelled' }
+        }
+      }
+
+      // Start provisioning
+      this.log(chalk.blue(`Submitting a request for a database to be provisioned for the '${this.rtNamespace}' namespace...`))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Region: ${region}`))
+
+      const provisionResult = await this.db.provisionRequest()
+      this.debugLogger?.info?.('Provision request result:', provisionResult)
+
+      // Handle different provision result statuses
+      const resultStatus = provisionResult?.status?.toUpperCase() || DB_STATUS.UNKNOWN
+
+      if (resultStatus === DB_STATUS.PROVISIONED) {
+        this.log(chalk.green('Database provisioned successfully and ready for use!'))
+      } else if (resultStatus === DB_STATUS.REQUESTED) {
+        this.log(chalk.blue('Database provisioning request submitted successfully'))
+        this.log(chalk.dim('Provisioning is now pending...'))
+      } else if (resultStatus === DB_STATUS.PROCESSING) {
+        this.log(chalk.yellow('Database is being provisioned...'))
+      } else if (resultStatus === DB_STATUS.FAILED) {
+        this.error(`Database provisioning failed: ${provisionResult.message || 'Unknown error'}`)
+      } else if (resultStatus === DB_STATUS.REJECTED) {
+        this.error(`Database provisioning request was rejected: ${provisionResult.message || 'Unknown reason'}`)
+      } else if (resultStatus === DB_STATUS.UNKNOWN) {
+        this.warn(`Database provisioning request returned unrecognized status '${provisionResult.status || 'undefined'}', an update to the aio cli tool may be necessary.`)
+        this.warn('If the issue persists, please contact the App Builder team.')
+      } else {
+        this.warn(`Database provisioning request returned unexpected status '${resultStatus}', an update to the aio cli tool may be necessary.`)
+        this.warn('If the issue persists, please contact the App Builder team.')
+      }
+
+      const result = {
+        status: resultStatus.toLowerCase(),
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString(),
+        details: provisionResult
+      }
+
+      // If region was specified as a CLI flag, include it in the output for next steps
+      const { region: regionFlag } = this.flags
+      const regionFlagString = regionFlag ? ` --region ${regionFlag}` : ''
+
+      if (resultStatus !== DB_STATUS.PROVISIONED) {
+        this.log(chalk.dim('\nNext steps:'))
+        this.log(chalk.dim(`   - Monitor progress: aio app db status${regionFlagString} --watch`))
+        this.log(chalk.dim(`   - Check status: aio app db status${regionFlagString}`))
+      } else {
+        this.log(chalk.dim('\nNext steps:'))
+        this.log(chalk.dim(`   - Test connection: aio app db ping${regionFlagString}`))
+      }
+
+      return result
+    } catch (error) {
+      this.debugLogger?.error?.('Provision command error:', error)
+      this.error(`Database provisioning failed: ${error.message}`)
+    }
+  }
+}
+
+Provision.description = 'Provision a new database for your App Builder application'
+
+Provision.examples = [
+  '$ aio app db provision',
+  '$ aio app db provision --region amer',
+  '$ aio app db provision --json',
+  '$ aio app db provision --yes'
+]
+
+Provision.flags = {
+  ...DBBaseCommand.flags,
+  yes: Flags.boolean({
+    char: 'y',
+    description: 'Skip confirmation prompt and provision automatically',
+    default: false
+  })
+}
+
+Provision.args = {}

package/src/commands/app/db/stats.js

@@ -0,0 +1,87 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../DBBaseCommand.js'
+import chalk from 'chalk'
+import { prettyJson } from '../../../utils/output.js'
+
+export class Stats extends DBBaseCommand {
+  async run () {
+    try {
+      this.log(chalk.blue('Fetching database statistics...'))
+
+      const client = await this.db.connect()
+      const stats = await client.dbStats()
+
+      this.debugLogger?.info?.('Database statistics retrieved:', stats)
+
+      const result = {
+        ...stats,
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString()
+      }
+
+      this.displayStats(stats)
+
+      return result
+    } catch (error) {
+      this.debugLogger?.error?.('Stats command error:', error)
+
+      this.log(chalk.red('Failed to retrieve database statistics'))
+      this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+      this.log(chalk.dim(`   Error: ${error.message}`))
+
+      this.error(`Failed to fetch database statistics: ${error.message}`)
+    }
+  }
+
+  displayStats (stats) {
+    this.log(chalk.green('Database Statistics:'))
+    this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+
+    if (stats && typeof stats === 'object') {
+      // Format and display stats in a readable way
+      Object.entries(stats).forEach(([key, value]) => {
+        this.log(chalk.dim(`   ${key}: ${this.formatValue(value)}`))
+      })
+    } else {
+      this.log(chalk.dim(`   Raw Stats: ${this.formatValue(stats)}`))
+    }
+
+    this.log('')
+    this.log(chalk.dim(`   Retrieved: ${new Date().toLocaleString()}`))
+  }
+
+  formatValue (value) {
+    if (typeof value === 'number') {
+      // Format large numbers with commas
+      return value.toLocaleString()
+    }
+    if (typeof value === 'object' && value !== null) {
+      return `\n${prettyJson(value)}`
+    }
+    return String(value)
+  }
+}
+
+Stats.description = 'Get statistics about your App Builder database'
+
+Stats.examples = [
+  '$ aio app db stats',
+  '$ aio app db stats --json'
+]
+
+Stats.flags = {
+  ...DBBaseCommand.flags
+}
+
+Stats.args = {}

package/src/commands/app/db/status.js

@@ -0,0 +1,159 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { DBBaseCommand } from '../../../DBBaseCommand.js'
+import { Flags } from '@oclif/core'
+import chalk from 'chalk'
+import { DB_STATUS } from '../../../constants/db.js'
+
+export class Status extends DBBaseCommand {
+  async run () {
+    const { watch } = this.flags
+
+    this.debugLogger?.info?.('Checking database provisioning status')
+
+    if (watch) {
+      return this.watchStatus()
+    } else {
+      return this.checkStatus()
+    }
+  }
+
+  async checkStatus () {
+    try {
+      this.log(chalk.blue('Checking database provisioning status...'))
+
+      const provisionStatusResponse = await this.db.provisionStatus()
+      this.debugLogger?.info?.('Status result:', provisionStatusResponse)
+
+      this.displayStatus(provisionStatusResponse)
+
+      return {
+        ...provisionStatusResponse,
+        namespace: this.rtNamespace,
+        timestamp: new Date().toISOString()
+      }
+    } catch (error) {
+      this.debugLogger?.error?.('Status command error:', error)
+
+      if (error.httpStatusCode === 404) {
+        this.log(chalk.yellow('No database has been provisioned for this workspace'))
+        this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+        this.log(chalk.dim(`   Status: ${DB_STATUS.NOT_PROVISIONED}`))
+
+        return {
+          status: DB_STATUS.NOT_PROVISIONED,
+          namespace: this.rtNamespace,
+          timestamp: new Date().toISOString()
+        }
+      }
+
+      this.error(`Failed to check database status: ${error.message}`)
+    }
+  }
+
+  async watchStatus () {
+    this.log(chalk.blue('Watching database provisioning status (press Ctrl+C to stop)...'))
+
+    let previousStatus = null
+    const checkInterval = 3000 // 3 seconds
+
+    const watchLoop = async () => {
+      try {
+        const provisionStatusResponse = await this.db.provisionStatus()
+
+        // Only display if status changed
+        if (previousStatus?.status !== provisionStatusResponse?.status) {
+          this.log(chalk.dim(`\n[${new Date().toLocaleTimeString()}]`))
+          this.displayStatus(provisionStatusResponse, false) // Don't show timestamp in watch mode
+          previousStatus = provisionStatusResponse
+
+          // Stop watching if provisioning is complete or failed
+          const currentStatus = provisionStatusResponse.status?.toUpperCase()
+          if (currentStatus !== DB_STATUS.REQUESTED && currentStatus !== DB_STATUS.PROCESSING) {
+            this.log(chalk.dim('\nStopping watch mode.'))
+            return provisionStatusResponse
+          }
+        }
+
+        // Schedule next check
+        setTimeout(watchLoop, checkInterval)
+      } catch (error) {
+        this.debugLogger?.error?.('Watch status error:', error)
+        this.log(chalk.red(`\n[${new Date().toLocaleTimeString()}] Error: ${error.message}`))
+
+        // Continue watching despite errors
+        setTimeout(watchLoop, checkInterval)
+      }
+    }
+
+    // Start watching
+    return watchLoop()
+  }
+
+  displayStatus (provisionStatusResponse, showTimestamp = true) {
+    const currentStatus = provisionStatusResponse.status.toUpperCase()
+    const statusColor = this.getStatusColor(currentStatus)
+
+    this.log(statusColor(`Database Status: ${currentStatus}`))
+    this.log(chalk.dim(`   Namespace: ${this.rtNamespace}`))
+
+    if (provisionStatusResponse.message) {
+      this.log(chalk.dim(`   Message: ${provisionStatusResponse.message}`))
+    }
+
+    if (provisionStatusResponse.submitted) {
+      this.log(chalk.dim(`   Submitted: ${new Date(provisionStatusResponse.submitted).toLocaleString()}`))
+    }
+
+    if (showTimestamp) {
+      this.log(chalk.dim(`   Checked: ${new Date().toLocaleString()}`))
+    }
+  }
+
+  /* istanbul ignore next */
+  getStatusColor (statusValue) {
+    const status = statusValue.toUpperCase()
+    switch (status) {
+      case DB_STATUS.PROVISIONED:
+        return chalk.green
+      case DB_STATUS.REQUESTED:
+      case DB_STATUS.PROCESSING:
+        return chalk.yellow
+      case DB_STATUS.FAILED:
+      case DB_STATUS.REJECTED:
+        return chalk.red
+      case DB_STATUS.NOT_PROVISIONED:
+        return chalk.blue
+      default:
+        return chalk.gray
+    }
+  }
+}
+
+Status.description = 'Check the provisioning status of your App Builder database'
+
+Status.examples = [
+  '$ aio app db status',
+  '$ aio app db status --watch',
+  '$ aio app db status --json'
+]
+
+Status.flags = {
+  ...DBBaseCommand.flags,
+  watch: Flags.boolean({
+    description: 'Watch for status changes (press Ctrl+C to stop)',
+    default: false
+  })
+}
+
+Status.args = {}

package/src/commands/app/state/delete.js

@@ -10,12 +10,12 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import chalk from 'chalk'
-import { BaseCommand } from '../../../BaseCommand.js'
+import { StateBaseCommand } from '../../../StateBaseCommand.js'
 import { Args, Flags } from '@oclif/core'
 
 const MAX_ARGV_NO_CONFIRM = 5
 
-export class Delete extends BaseCommand {
+export class Delete extends StateBaseCommand {
   async run () {
     const { match, force } = this.flags
     const { argv: keysToDelete } = await this.parse(Delete)
@@ -100,7 +100,7 @@ Delete.args = {
 }
 
 Delete.flags = {
-  ...BaseCommand.flags,
+  ...StateBaseCommand.flags,
   match: Flags.string({
     description: '[use with caution!] deletes ALL key-values matching the provided glob-like pattern',
     required: false

package/src/commands/app/state/get.js

@@ -10,10 +10,10 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import chalk from 'chalk'
-import { BaseCommand } from '../../../BaseCommand.js'
+import { StateBaseCommand } from '../../../StateBaseCommand.js'
 import { Args } from '@oclif/core'
 
-export class Get extends BaseCommand {
+export class Get extends StateBaseCommand {
   async run () {
     const ret = await this.state.get(this.args.key)
 

package/src/commands/app/state/list.js

@@ -9,14 +9,14 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { BaseCommand } from '../../../BaseCommand.js'
+import { StateBaseCommand } from '../../../StateBaseCommand.js'
 import { Flags } from '@oclif/core'
 import chalk from 'chalk'
 
 const MAX_KEYS = 5000
 const COUNT_HINT = 500 // per iteration
 
-export class List extends BaseCommand {
+export class List extends StateBaseCommand {
   async run () {
     const allKeys = []
 
@@ -55,7 +55,7 @@ List.examples = [
 ]
 
 List.flags = {
-  ...BaseCommand.flags,
+  ...StateBaseCommand.flags,
   match: Flags.string({
     name: 'match',
     char: 'm',

package/src/commands/app/state/put.js

@@ -9,12 +9,12 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { BaseCommand } from '../../../BaseCommand.js'
+import { StateBaseCommand } from '../../../StateBaseCommand.js'
 import { Args, Flags } from '@oclif/core'
-import { DEFAULT_TTL_SECONDS } from '../../../constants.js'
+import { DEFAULT_TTL_SECONDS } from '../../../constants/state.js'
 import chalk from 'chalk'
 
-export class Put extends BaseCommand {
+export class Put extends StateBaseCommand {
   async run () {
     const { key, value } = this.args
     const { json, ttl } = this.flags
@@ -55,7 +55,7 @@ Put.args = {
 }
 
 Put.flags = {
-  ...BaseCommand.flags,
+  ...StateBaseCommand.flags,
   ttl: Flags.integer({
     char: 't',
     description: 'Time to live in seconds. Default is 86400 (24 hours), max is 31536000 (1 year).',