heroku 10.13.2 → 11.0.0-alpha.1

package/lib/oldCommands/spaces/wait.js

@@ -0,0 +1,106 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+import debug from 'debug'
+import {renderInfo} from '../../lib/spaces/spaces'
+import {Notification, notify} from '@heroku-cli/notifications'
+import {IncomingHttpHeaders} from 'node:http'
+import {SpaceNat} from '../../lib/types/fir'
+import {SpaceWithOutboundIps} from '../../lib/types/spaces'
+
+const spacesDebug = debug('spaces:wait')
+
+export default class Wait extends Command {
+  static topic = 'spaces'
+  static description = 'wait for a space to be created'
+  static flags = {
+    space: flags.string({char: 's', description: 'space to get info of'}),
+    json: flags.boolean({description: 'output in json format'}),
+    interval: flags.integer({
+      char: 'i',
+      description: 'seconds to wait between poll intervals',
+      default: 30,
+    }),
+    timeout: flags.integer({
+      char: 't',
+      description: 'maximum number of seconds to wait',
+      default: 25 * 60,
+    }),
+  }
+
+  static args = {
+    space: Args.string({hidden: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Wait)
+    const spaceName = flags.space || args.space
+    if (!spaceName) {
+      ux.error(heredoc(`
+        Error: Missing 1 required arg:
+        space
+        See more help with --help
+      `))
+    }
+
+    const interval = flags.interval * 1000
+    const timeout = flags.timeout * 1000
+    const deadline = new Date(Date.now() + timeout)
+    const action = new Spinner()
+    action.start(`Waiting for space ${color.green(spaceName as string)} to allocate`)
+
+    const headers: IncomingHttpHeaders = {
+      Accept: 'application/vnd.heroku+json; version=3.fir',
+    }
+    if (!flags.json) {
+      headers['Accept-Expansion'] = 'region'
+    }
+
+    let {body: space} = await this.heroku.get<SpaceWithOutboundIps>(`/spaces/${spaceName}`, {headers})
+    while (space.state === 'allocating') {
+      if (new Date() > deadline) {
+        throw new Error('Timeout waiting for space to become allocated.')
+      }
+
+      await this.wait(interval)
+      const {body: updatedSpace} = await this.heroku.get<SpaceWithOutboundIps>(`/spaces/${spaceName}`, {headers})
+      space = updatedSpace
+    }
+
+    try {
+      const {body: nat} = await this.heroku.get<SpaceNat>(`/spaces/${spaceName}/nat`, {headers: {Accept: 'application/vnd.heroku+json; version=3.fir'}})
+      space.outbound_ips = nat
+    } catch (error) {
+      spacesDebug(`Retrieving NAT details for the space failed with ${error}`)
+    }
+
+    action.stop()
+    renderInfo(space, flags.json)
+    this.notify(spaceName as string)
+  }
+
+  protected wait(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+
+  protected notify(spaceName: string) {
+    try {
+      const notification: Notification & {
+        sound?: boolean, message?: string, title?: string, subtitle?: string
+      } = {
+        title: spaceName,
+        subtitle: `heroku spaces:wait ${spaceName}`,
+        message: 'space was successfully created',
+        sound: true,
+      }
+      notify(notification)
+    } catch (error: any) {
+      ux.warn(error)
+    }
+  }
+}
+*/

package/lib/oldCommands/webhooks/add.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/add.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+
+import BaseCommand from '../../lib/webhooks/base'
+
+export default class WebhooksAdd extends BaseCommand {
+  static description = 'add a webhook to an app'
+
+  static examples = [
+    '$ heroku webhooks:add -i api:dyno -l notify -u https://example.com/hooks',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+    include: flags.string({char: 'i', description: 'comma delimited event types your server will receive ', required: true}),
+    level: flags.string({char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true}),
+    secret: flags.string({char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header'}),
+    authorization: flags.string({char: 't', description: 'authorization header to send with webhooks'}),
+    url: flags.string({char: 'u', description: 'URL for receiver', required: true}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(WebhooksAdd)
+    const {path, display} = this.webhookType(flags)
+    const action = new Spinner()
+
+    action.start(`Adding webhook to ${display}`)
+
+    const response = await this.webhooksClient.post(`${path}/webhooks`, {
+      body: {
+        include: flags.include.split(',').map(s => s.trim()),
+        level: flags.level,
+        secret: flags.secret,
+        url: flags.url,
+        authorization: flags.authorization,
+      },
+    })
+
+    const secret = response.headers && response.headers['heroku-webhook-secret'] as string
+    if (secret) {
+      hux.styledHeader('Webhooks Signing Secret')
+      this.log(secret)
+    } else {
+      ux.warn('no secret found')
+    }
+
+    action.stop()
+  }
+}
+*/

package/lib/oldCommands/webhooks/deliveries/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/deliveries/index.js

@@ -0,0 +1,90 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class Deliveries extends BaseCommand {
+  static description = 'list webhook deliveries on an app'
+
+  static examples = [
+    '$ heroku webhooks:deliveries',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    status: flags.string({char: 's', description: 'filter deliveries by status'}),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Deliveries)
+    const webhookType = this.webhookType(flags)
+    let {path} = webhookType
+    const {display} = webhookType
+    const max = 1000
+
+    path = `${path}/webhook-deliveries`
+    if (flags.status) {
+      path += `?eq[status]=${encodeURIComponent(flags.status)}`
+    }
+
+    const {body: deliveries}: { body: any[]} = await this.webhooksClient.get(path, {
+      headers: {
+        Range: `seq ..; order=desc,max=${max}`,
+      },
+      partial: true,
+    })
+
+    if (deliveries.length === 0) {
+      this.log(`${display} has no deliveries`)
+    } else {
+      const code = (w: any) => {
+        return (w.last_attempt && w.last_attempt.code && String(w.last_attempt.code)) || ''
+      }
+
+      deliveries.reverse()
+
+      if (deliveries.length === max) {
+        this.warn(`Only showing the ${max} most recent deliveries`)
+        this.warn('It is possible to filter deliveries by using the --status flag')
+      }
+
+      const printLine: typeof this.log = (...args) => this.log(...args)
+      hux.table(deliveries, {
+        id: {
+          header: 'Delivery ID',
+        },
+        created_at: {
+          header: 'Created', get: (w: any) => w.created_at,
+        },
+        status: {
+          get: (w: any) => w.status,
+        },
+        include: {
+          get: (w: any) => w.event.include,
+        },
+        level: {
+          get: (w: any) => w.webhook.level,
+        },
+        num_attempts: {
+          header: 'Attempts', get: (w: any) => String(w.num_attempts),
+        },
+        last_code: {
+          header: 'Code', get: code,
+        },
+        last_error: {
+          header: 'Error', get: (w: any) => (w.last_attempt && w.last_attempt.error_class) || '',
+        },
+        next_attempt_at: {
+          header: 'Next Attempt', get: (w: any) => w.next_attempt_at || '',
+        },
+      }, {
+        'no-header': false, printLine,
+      })
+    }
+  }
+}
+*/

package/lib/oldCommands/webhooks/deliveries/info.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/deliveries/info.js

@@ -0,0 +1,54 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class DeliveriesInfo extends BaseCommand {
+  static description = 'info for a webhook event on an app'
+
+  static examples = [
+    '$ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  static args = {
+    id: Args.string({required: true, description: 'ID of the webhook event'}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(DeliveriesInfo)
+    const {path} = this.webhookType(flags)
+
+    const {body: delivery}: {body: any} = await this.webhooksClient.get(`${path}/webhook-deliveries/${args.id}`)
+
+    const {body: event}: {body: any} = await this.webhooksClient.get(`${path}/webhook-events/${delivery.event.id}`)
+
+    const obj = {
+      Created: delivery.created_at,
+      Event: delivery.event.id,
+      Webhook: delivery.webhook.id,
+      Status: delivery.status,
+      Include: delivery.event.include,
+      Level: delivery.webhook.level,
+      Attempts: delivery.num_attempts,
+      Code: delivery.last_attempt && delivery.last_attempt.code,
+      Error: delivery.last_attempt && delivery.last_attempt.error_class,
+      'Next Attempt': delivery.next_attempt_at,
+    }
+
+    hux.styledHeader(delivery.id)
+    hux.styledObject(obj)
+
+    hux.styledHeader('Event Payload')
+    hux.styledJSON(event.payload)
+  }
+}
+*/

package/lib/oldCommands/webhooks/events/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/events/index.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class EventsIndex extends BaseCommand {
+  static description = 'list webhook events on an app'
+
+  static examples = [
+    '$ heroku webhooks:events',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(EventsIndex)
+    const {path, display} = this.webhookType(flags)
+
+    ux.warn('heroku webhooks:event is deprecated, please use heroku webhooks:deliveries')
+
+    const {body: events}: {body: any} = await this.webhooksClient.get(`${path}/webhook-events`)
+
+    if (events.length === 0) {
+      this.log(`${display} has no events`)
+    } else {
+      events.sort((a: any, b: any) => Date.parse(a.created_at) - Date.parse(b.created_at))
+
+      const printLine: typeof this.log = (...args) => this.log(...args)
+
+      hux.table(events, {
+        id: {
+          header: 'Event ID',
+        },
+        resource: {
+          get: (w: any) => w.payload.resource,
+        },
+        action: {
+          get: (w: any) => w.payload.action,
+        },
+        published_at: {
+          header: 'Published At', get: (w: any) => w.payload.published_at,
+        },
+      }, {
+        'no-header': false, printLine,
+      })
+    }
+  }
+}
+*/

package/lib/oldCommands/webhooks/events/info.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/events/info.js

@@ -0,0 +1,42 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../../lib/webhooks/base'
+
+export default class Info extends BaseCommand {
+  static description = 'info for a webhook event on an app'
+
+  static examples = [
+    '$ heroku webhooks:events:info 99999999-9999-9999-9999-999999999999',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  static args = {
+    id: Args.string({required: true, description: 'ID of the webhook event'}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(Info)
+    const {path} = this.webhookType(flags)
+
+    ux.warn('heroku webhooks:event:info is deprecated, please use heroku webhooks:deliveries:info')
+
+    const {body: webhookEvent}: {body: any} = await this.webhooksClient.get(`${path}/webhook-events/${args.id}`)
+
+    const obj = {
+      payload: JSON.stringify(webhookEvent.payload, null, 2),
+    }
+
+    hux.styledHeader(webhookEvent.id)
+    hux.styledObject(obj)
+  }
+}
+*/

package/lib/oldCommands/webhooks/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/index.js

@@ -0,0 +1,55 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {flags} from '@heroku-cli/command'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../lib/webhooks/base'
+
+export default class Webhooks extends BaseCommand {
+  static description = 'list webhooks on an app'
+
+  static examples = ['$ heroku webhooks']
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({
+      char: 'p',
+      description:
+      'pipeline on which to list',
+      hidden: true,
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Webhooks)
+    const {path, display} = this.webhookType(flags)
+
+    const {body: webhooks}: {body: any} = await this.webhooksClient.get(`${path}/webhooks`)
+
+    if (webhooks.length === 0) {
+      this.log(`${display} has no webhooks\nUse ${color.cmd('heroku webhooks:add')} to add one.`)
+      return
+    }
+
+    webhooks.sort((a: any, b: any) => Date.parse(a.created_at) - Date.parse(b.created_at))
+
+    const printLine: typeof this.log = (...args) => this.log(...args)
+    hux.table(webhooks, {
+      id: {
+        header: 'Webhook ID',
+      },
+      url: {
+        header: 'URL',
+      },
+      include: {
+        get: (row: any) => row.include.join(','),
+      },
+      level: {},
+    }, {
+      'no-header': false, printLine,
+    })
+  }
+}
+*/

package/lib/oldCommands/webhooks/info.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/info.js

@@ -0,0 +1,41 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import BaseCommand from '../../lib/webhooks/base'
+
+export default class WebhooksInfo extends BaseCommand {
+  static description = 'info for a webhook on an app'
+
+  static example = ['$ heroku webhooks:info 99999999-9999-9999-9999-999999999999']
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  static args = {
+    id: Args.string({required: true, description: 'ID of the webhook'}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(WebhooksInfo)
+    const {path} = this.webhookType(flags)
+
+    const {body: webhook}: {body: any} = await this.webhooksClient.get(`${path}/webhooks/${args.id}`)
+
+    const obj = {
+      'Webhook ID': webhook.id,
+      URL: webhook.url,
+      Include: webhook.include.join(','),
+      Level: webhook.level,
+    }
+
+    hux.styledHeader(webhook.id)
+    hux.styledObject(obj)
+  }
+}
+*/

package/lib/oldCommands/webhooks/remove.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/remove.js

@@ -0,0 +1,37 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+
+import BaseCommand from '../../lib/webhooks/base'
+export default class WebhooksRemove extends BaseCommand {
+  static description = 'removes a webhook from an app'
+
+  static examples = [
+    '$ heroku webhooks:remove 99999999-9999-9999-9999-999999999999',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+  }
+
+  static args = {
+    id: Args.string({description: 'id of webhook to remove', required: true}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(WebhooksRemove)
+    const {path, display} = this.webhookType(flags)
+    const action = new Spinner()
+
+    action.start(`Removing webhook ${args.id} from ${display}`)
+
+    await this.webhooksClient.delete(`${path}/webhooks/${args.id}`)
+
+    action.stop()
+  }
+}
+*/

package/lib/oldCommands/webhooks/update.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/webhooks/update.js

@@ -0,0 +1,50 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import Spinner from '@oclif/core/lib/cli-ux/action/spinner'
+
+import BaseCommand from '../../lib/webhooks/base'
+
+export default class WebhooksUpdate extends BaseCommand {
+  static description = 'updates a webhook in an app'
+
+  static examples = [
+    '$ heroku webhooks:update 99999999-9999-9999-9999-999999999999 -i dyno -l notify -s 09928c40bf1b191b645174a19f7053d16a180da37332e719ef0998f4c0a2 -u https://example.com/hooks',
+  ]
+
+  static flags = {
+    app: flags.app(),
+    remote: flags.remote(),
+    pipeline: flags.pipeline({char: 'p', description: 'pipeline on which to list', hidden: true}),
+    include: flags.string({char: 'i', description: 'comma delimited event types your server will receive ', required: true}),
+    level: flags.string({char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true}),
+    secret: flags.string({char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header'}),
+    authorization: flags.string({char: 't', description: 'authorization header to send with webhooks'}),
+    url: flags.string({char: 'u', description: 'URL for receiver', required: true}),
+  }
+
+  static args = {
+    id: Args.string({required: true, description: 'ID of the webhook'}),
+  }
+
+  async run() {
+    const {flags, args} = await this.parse(WebhooksUpdate)
+    const {path, display} = this.webhookType(flags)
+    const action = new Spinner()
+
+    action.start(`Updating webhook ${args.id} for ${display}`)
+
+    await this.webhooksClient.patch(`${path}/webhooks/${args.id}`, {
+      body: {
+        include: flags.include && flags.include.split(',').map(s => s.trim()),
+        level: flags.level,
+        secret: flags.secret,
+        url: flags.url,
+      },
+    })
+
+    action.stop()
+  }
+}
+*/

package/lib/user-config.d.ts

@@ -16,7 +16,6 @@ export default class UserConfig {
     set install(install: string);
     get skipAnalytics(): boolean;
     init(): Promise<void>;
-    private get debug();
     private get file();
     private save;
     private read;