クイックスタート

Authenticate → GET file/token → upload input.zip → POST task/submit → GET task/info → download output.zip

npm install @realsee/universal-uploader@0.1.1 @aws-sdk/client-s3@3.1084.0

input.zip
├── entrance.jpg
├── living-room.jpg
└── kitchen.jpg

import { Uploader } from '@realsee/universal-uploader'
import { AwsAdaptor } from '@realsee/universal-uploader/adaptors/aws'

const gateway = 'https://app-gateway.realsee.ai'

async function readData(response) {
  if (!response.ok) throw new Error(`Argus HTTP error: ${response.status}`)
  const payload = await response.json()
  if (payload.code !== 0 || !payload.data || typeof payload.data !== 'object' || Array.isArray(payload.data)) {
    throw new Error('Argus request was not successful')
  }
  return payload.data
}

export async function getArgusAccessToken() {
  const appKey = process.env.REALSEE_APP_KEY
  const appSecret = process.env.REALSEE_APP_SECRET
  if (!appKey || !appSecret) throw new Error('Configure server-side app credentials')
  const response = await fetch(`${gateway}/auth/access_token`, {
    method: 'POST',
    headers: { 'content-type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({ app_key: appKey, app_secret: appSecret }),
    signal: AbortSignal.timeout(30_000),
  })
  const data = await readData(response)
  if (typeof data.access_token !== 'string' || !data.access_token || !Number.isInteger(data.expire_at) || data.expire_at * 1000 <= Date.now()) {
    throw new Error('Argus returned an invalid access token')
  }
  return data.access_token
}

async function requestArgus(path, accessToken, body) {
  return readData(await fetch(`${gateway}${path}`, {
    method: body === undefined ? 'GET' : 'POST',
    headers: {
      authorization: accessToken,
      ...(body === undefined ? {} : { 'content-type': 'application/json' }),
    },
    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
    signal: AbortSignal.timeout(30_000),
  }))
}

export async function createArgusUpload(accessToken) {
  const lease = await requestArgus('/open/v1/argus/file/token', accessToken)
  for (const field of ['tmpSecretId', 'tmpSecretKey', 'sessionToken', 'bucket', 'region', 'prefix']) {
    if (typeof lease[field] !== 'string' || !lease[field]) {
      throw new Error('Argus returned an incomplete upload lease')
    }
  }
  return lease
}

export async function uploadArgusZip(accessToken, filePath) {
  const uploader = new Uploader(AwsAdaptor, {
    getToken: () => createArgusUpload(accessToken),
  })
  const receipt = await uploader.uploadFile('input.zip', filePath)
  if (!receipt.objectPath) throw new Error('Upload did not return a full object key')
  return receipt.objectPath
}

export async function submitArgusTask(accessToken, privateCosKey, title) {
  if (!privateCosKey || !title?.trim()) throw new Error('Object key and title are required')
  // Submit once. A lost response can mean the server already created the task.
  const data = await requestArgus('/open/v1/argus/task/submit', accessToken, {
    private_cos_keys: [privateCosKey],
    title,
  })
  if (typeof data.task_code !== 'string' || !data.task_code) {
    throw new Error('Submission returned no task code; do not resubmit automatically')
  }
  return data.task_code
}

export async function pollArgusTask(accessToken, taskCode) {
  if (!taskCode) throw new Error('Task code is required')
  const query = new URLSearchParams({ task_code: taskCode })
  // Ten minutes is this example's waiting policy, not a service completion SLA.
  for (let attempt = 0; attempt < 300; attempt += 1) {
    const data = await requestArgus(`/open/v1/argus/task/info?${query}`, accessToken)
    if (data.status === 2) {
      if (typeof data.output_url !== 'string' || !data.output_url || !Number.isInteger(data.expiration_timestamp) ||
          data.expiration_timestamp * 1000 <= Date.now()) {
        throw new Error('Task succeeded without a usable result URL; query task info again')
      }
      return data
    }
    if (data.status === 3) throw new Error('Argus task failed; inspect its task info on your backend')
    if (data.status !== 0 && data.status !== 1) throw new Error('Unexpected Argus task status')
    await new Promise((resolve) => setTimeout(resolve, 2000))
  }
  throw new Error('Stopped waiting; resume queries with the existing task code')
}

import { getArgusAccessToken, uploadArgusZip, submitArgusTask } from './argus.mjs'

const accessToken = await getArgusAccessToken()
const privateCosKey = await uploadArgusZip(accessToken, './input.zip')
const taskCode = await submitArgusTask(accessToken, privateCosKey, 'My reconstruction')
// Persist taskCode with your task record before starting status queries.