Documentation

import AltoHost from '@girardmedia/altohost-node'

const alto = new AltoHost({
  appId: process.env.ALTOHOST_APP_ID,
  key: process.env.ALTOHOST_KEY,
  secret: process.env.ALTOHOST_SECRET,
  host: 'app.altohost.com',
  useTLS: true,
  dashboardHost: 'https://app.altohost.com',
  dashboardApiKey: process.env.ALTOHOST_API_TOKEN,
})

// Submit a job
await alto.jobs.submit('emails', 'send-welcome', { userId: 'u_123' })

// Check job status
const job = await alto.jobs.get('job_abc')

// List jobs in a queue
const jobs = await alto.jobs.list({ queue: 'emails', status: 'completed' })

// Retry a failed job
await alto.jobs.retry('job_abc')

import AltoHost from '@girardmedia/altohost-js'

const alto = new AltoHost(key, { wsHost: 'ws.altohost.com' })

// Subscribe to job events for your app
const channel = alto.subscribe('private-jobs-YOUR_APP_ID')

channel.on('job.active', (data) => {
  console.log('Job started:', data.jobId, data.name)
})

channel.on('job.completed', (data) => {
  console.log('Job done:', data.jobId, data.result)
})

channel.on('job.failed', (data) => {
  console.error('Job failed:', data.jobId, data.error)
})

// Send a raw email
await alto.email.send({
  to: 'user@example.com',
  subject: 'Welcome to our app',
  html: '<h1>Welcome!</h1>',
})

// Send from a template
await alto.email.sendTemplate('welcome', {
  to: 'user@example.com',
  variables: { name: 'Alice', link: 'https://...' },
})

// Get delivery history
const history = await alto.email.history({ limit: 50 })

// Set a value (TTL in seconds)
await alto.cache.set('user:123', JSON.stringify({ name: 'Alice' }), 3600)

// Get a value
const data = await alto.cache.get('user:123')

// Delete a key
await alto.cache.del('user:123')

// List keys and stats
const keys = await alto.cache.keys('user:*')
const stats = await alto.cache.stats()

// Flush all keys for this app
await alto.cache.flush()

// Publish an event to a stream channel
await alto.stream.publish('feed', 'update', { message: 'New item' })

// Get active stream stats
const stats = await alto.stream.stats()

import AltoHost from '@girardmedia/altohost-js'

const alto = new AltoHost(key, { wsHost: 'ws.altohost.com' })

// Open an SSE stream
const stream = alto.stream('feed')
stream.on('update', (data) => {
  console.log(data.message)
})

// Get your VAPID public key (for client-side subscription)
const { publicKey} = await alto.push.getVapidKey()

// Register a push subscription from the browser
await alto.push.subscribe({
  endpoint: subscription.endpoint,
  keys: { p256dh: subscription.keys.p256dh, auth: subscription.keys.auth },
  userTag: 'user_123',
})

// Send a push notification to all subscribers
await alto.push.send({
  title: 'New Message',
  body: 'You have a new notification',
  icon: '/icon-192.png',
  url: 'https://app.example.com/inbox',
  userTag: 'user_123',
})

// List subscriptions and delivery history
const subs = await alto.push.listSubscriptions({ userTag: 'user_123' })
const history = await alto.push.history({ limit: 50 })

// Create a video room
const { room} = await alto.video.createRoom('team-standup', {
  maxParticipants: 10,
  emptyTimeout: 300,
})

// Generate a participant token
const { token, serverUrl} = await alto.video.createToken({
  room: 'team-standup',
  identity: 'user_123',
  name: 'Alice',
  permissions: { canPublish: true, canSubscribe: true },
  ttlSeconds: 3600,
})

// List rooms and participants
const { rooms} = await alto.video.listRooms()
const { participants} = await alto.video.listParticipants('team-standup')

// Clean up
await alto.video.deleteRoom('team-standup')

// Create a conversation
const convo = await alto.messaging.createConversation({
  type: 'GROUP',
  title: 'Project Chat',
  participants: [
    { externalUserId: 'user_1', displayName: 'Alice', role: 'OWNER' },
    { externalUserId: 'user_2', displayName: 'Bob' },
  ],
})

// Send a message
await alto.messaging.sendMessage(convo.id, {
  senderUserId: 'user_1',
  content: 'Hey team, ready for the launch?',
})

// List messages with cursor pagination
const messages = await alto.messaging.listMessages(convo.id, { limit: 25 })

// Mark conversation as read
await alto.messaging.markRead(convo.id, 'user_2')

// Add a participant
await alto.messaging.addParticipant(convo.id, {
  externalUserId: 'user_3',
  displayName: 'Carol',
  role: 'MEMBER',
})

// Create a track
const track = await alto.audio.createTrack({
  title: 'Episode 42 — Launch Day',
  artist: 'AltoHost Podcast',
  category: 'podcast',
  durationMs: 1800000,
})

// List tracks with filtering
const tracks = await alto.audio.listTracks({
  category: 'podcast',
  published: 'true',
  limit: 20,
})

// Get a signed playback URL (expires in 1 hour)
const playback = await alto.audio.getPlayUrl(track.id, 3600)

// Update and delete
await alto.audio.updateTrack(track.id, { isPublished: true })
await alto.audio.deleteTrack(track.id)

// Browse categories
const categories = await alto.audio.listCategories()

import fs from 'fs'

const imageBuffer = fs.readFileSync('photo.jpg')

// Resize and convert to WebP
const result = await alto.images.transform(imageBuffer, {
  width: 800,
  height: 600,
  fit: 'cover',
  format: 'webp',
  quality: 85,
})
// result.buffer — processed image data
// result.width, result.height, result.format, result.size

// Get image metadata without transforming
const info = await alto.images.info(imageBuffer)
// info.width, info.height, info.format, info.hasAlpha

// View usage stats
const stats = await alto.images.stats()

import fs from 'fs'

const imageBuffer = fs.readFileSync('receipt.png')

// Extract text (default: English)
const result = await alto.ocr.extract(imageBuffer)
console.log(result.text)          // full extracted text
console.log(result.confidence)    // 0-100 confidence score
console.log(result.wordCount)     // total words found

// Extract with specific language
const french = await alto.ocr.extract(imageBuffer, 'fra')

// Access word-level detail
result.words.forEach((w) => {
  console.log(w.text, w.confidence, w.bbox)
})

// View usage stats
const stats = await alto.ocr.stats()

// Create an index
await alto.search.createIndex('products', 'id')

// Add documents
await alto.search.addDocuments('products', [
  { id: 1, name: 'Wireless Headphones', price: 79, category: 'audio' },
  { id: 2, name: 'USB-C Hub', price: 45, category: 'accessories' },
  { id: 3, name: 'Mechanical Keyboard', price: 129, category: 'input' },
])

// Search with options
const results = await alto.search.search('products', 'wireless', {
  limit: 10,
  attributesToHighlight: ['name'],
  showRankingScore: true,
})
// results.hits, results.estimatedTotalHits, results.processingTimeMs

// List indexes and stats
const { indexes} = await alto.search.listIndexes()
const stats = await alto.search.stats()

// Delete documents or an entire index
await alto.search.deleteDocuments('products', [1, 2])
await alto.search.deleteIndex('products')

// Create a transcode job
const { job, uploadUrl} = await alto.media.submit({
  type: 'TRANSCODE',
  contentType: 'video/mp4',
  options: { format: 'webm', videoBitrate: '1M' },
})

// Upload the file to the signed URL
await fetch(uploadUrl, {
  method: 'PUT',
  body: fileBuffer,
  headers: { 'Content-Type': 'video/mp4' },
})

// Start processing after upload
await alto.media.start(job.id)

// Check status
const status = await alto.media.get(job.id)

// List jobs and view stats
const jobs = await alto.media.list({ status: 'COMPLETED', limit: 20 })
const stats = await alto.media.stats()

// Create a workflow
const workflow = await alto.workflows.create({
  name: 'Welcome Sequence',
  description: 'Onboarding email drip campaign',
})

// Update workflow definition (nodes, edges, config)
await alto.workflows.update(workflow.id, {
  nodes: [
    { id: '1', type: 'trigger', data: { label: 'User Signs Up' } },
    { id: '2', type: 'email', data: { template: 'welcome' } },
  ],
  edges: [{ source: '1', target: '2' }],
})

// Activate the workflow
await alto.workflows.setStatus(workflow.id, 'ACTIVE')

// Run a workflow manually
await alto.workflows.run(workflow.id, { userId: 'u_123' })

// List execution history
const runs = await alto.workflows.listRuns(workflow.id, { limit: 20 })

// Duplicate a workflow
await alto.workflows.duplicate(workflow.id)

// Create an agent
const { agent } = await alto.agents.create({
  name: 'Support Bot',
  systemPrompt: 'You are a helpful support agent...',
  model: 'gpt-4o',
  tools: ['send_email', 'cache_get', 'search_query'],
  memoryEnabled: true,
})

// Execute the agent
const { run } = await alto.agents.run(agent.id, 'Handle support ticket #1234')

// Check run status
const { run: result } = await alto.agents.getRun(agent.id, run.id)

// 1. Get presigned upload URL
const { url, key } = await alto.storage.upload(
  'images/logo.png', 'image/png', 204800
)

// 2. Upload directly to storage (client-side)
await fetch(url, {
  method: 'PUT',
  body: fileBuffer,
  headers: { 'Content-Type': 'image/png' },
})

// 3. Confirm upload
await alto.storage.confirmUpload('images/logo.png', 'image/png', 204800)

// 4. Get download URL
const { downloadUrl } = await alto.storage.download('images/logo.png')

// 5. List objects
const { objects, total } = await alto.storage.list({ prefix: 'images/' })

// 6. Get usage stats
const stats = await alto.storage.stats()

// Create a cron job
const job = await alto.crons.create(appId, {
  name: 'Daily Cleanup',
  cron: '0 0 * * *',
  targetType: 'http',
  targetConfig: { url: 'https://api.example.com/cleanup' },
})

// List cron jobs
const { cronJobs, total } = await alto.crons.list(appId)

// Execute manually
const result = await alto.crons.execute(appId, cronJobId)

// Create a flag
const flag = await alto.flags.create(appId, {
  key: 'new-checkout',
  name: 'New Checkout Flow',
  type: 'boolean',
  defaultValue: false,
})

// Evaluate with context
const { value, reason } = await alto.flags.evaluate(appId, {
  key: 'new-checkout',
  context: { userId: 'user_123', plan: 'pro' },
})

// List all flags
const { flags, total } = await alto.flags.list(appId)

// Create a relay
const relay = await alto.relay.create(appId, {
  name: 'Stripe Webhooks',
  slug: 'stripe',
  routeType: 'workflow',
  routeConfig: { workflowId: 'wf_abc123' },
})

// Inbound URL: POST /api/apps/:id/relay/stripe
// List relays
const { relays, total } = await alto.relay.list(appId)

// View event history
const { events } = await alto.relay.events(appId, 'stripe')