peardock/client/api.js

/**
 * Typed peardock RPC API over an active connection / manager.
 * UI and tools should prefer these helpers over raw method strings.
 */
import { Methods } from '../shared/protocol.js'
import { manager } from './manager.js'

function connOrActive(connection) {
  const c = connection || manager.active
  if (!c?.connected) throw new Error('Not connected')
  return c
}

export const api = {
  Methods,

  handshake(info = {}, connection) {
    return connOrActive(connection).request(Methods.handshake, {
      clientName: info.clientName || 'peardock-api',
      clientVersion: info.clientVersion || null,
    })
  },

  ping(connection) {
    return connOrActive(connection).ping()
  },

  // —— Containers ——
  listContainers(opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    return connOrActive(connection).request(Methods.listContainers, opts)
  },

  validateCreateOptions(options, opts = {}, connection) {
    return connOrActive(connection).request(Methods.validateCreateOptions, {
      options,
      ...opts,
    })
  },

  inspectContainer(id, connection) {
    return connOrActive(connection).request(Methods.inspectContainer, { id })
  },

  checkImageUpdates(opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    return connOrActive(connection).request(Methods.checkImageUpdates, opts)
  },

  startContainer(id, connection) {
    return connOrActive(connection).request(Methods.startContainer, { id })
  },

  stopContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.stopContainer, { id, ...opts })
  },

  restartContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.restartContainer, { id, ...opts })
  },

  killContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.killContainer, { id, ...opts })
  },

  pauseContainer(id, connection) {
    return connOrActive(connection).request(Methods.pauseContainer, { id })
  },

  unpauseContainer(id, connection) {
    return connOrActive(connection).request(Methods.unpauseContainer, { id })
  },

  removeContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.removeContainer, { id, ...opts })
  },

  renameContainer(id, name, connection) {
    return connOrActive(connection).request(Methods.renameContainer, { id, name })
  },

  updateContainer(id, update, connection) {
    return connOrActive(connection).request(Methods.updateContainer, { id, ...update })
  },

  containerTop(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.containerTop, { id, ...opts })
  },

  containerStats(id, connection) {
    return connOrActive(connection).request(Methods.containerStats, { id })
  },

  waitContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.waitContainer, { id, ...opts })
  },

  pruneContainers(opts = {}, connection) {
    return connOrActive(connection).request(Methods.pruneContainers, opts)
  },

  archiveGet(id, path, opts = {}, connection) {
    return connOrActive(connection).request(Methods.archiveContainerGet, { id, path, ...opts })
  },

  archivePut(id, path, data, opts = {}, connection) {
    return connOrActive(connection).request(Methods.archiveContainerPut, {
      id,
      path,
      data,
      ...opts,
    })
  },

  deployContainer(args, connection) {
    return connOrActive(connection).request(Methods.deployContainer, args)
  },

  bulkContainerOperation(containerIds, operation, opts = {}, connection) {
    return connOrActive(connection).request(Methods.bulkContainerOperation, {
      containerIds,
      operation,
      ...opts,
    })
  },

  // —— Images ——
  listImages(opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    return connOrActive(connection).request(Methods.listImages, opts)
  },

  binaryStreamOpen(args, connection) {
    return connOrActive(connection).request(Methods.binaryStreamOpen, args)
  },

  binaryStreamChunk(streamId, data, opts = {}, connection) {
    return connOrActive(connection).request(Methods.binaryStreamChunk, {
      streamId,
      data,
      ...opts,
    })
  },

  binaryStreamClose(streamId, connection) {
    return connOrActive(connection).request(Methods.binaryStreamClose, { streamId })
  },

  pullImage(image, opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    const body = typeof image === 'object' && image ? { ...image } : { image, ...opts }
    return connOrActive(connection).request(Methods.pullImage, body)
  },

  removeImage(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.removeImage, { id, ...opts })
  },

  inspectImage(id, connection) {
    return connOrActive(connection).request(Methods.inspectImage, { id })
  },

  imageHistory(id, connection) {
    return connOrActive(connection).request(Methods.imageHistory, { id })
  },

  searchImages(term, opts = {}, connection) {
    return connOrActive(connection).request(Methods.searchImages, { term, ...opts })
  },

  pruneImages(opts = {}, connection) {
    return connOrActive(connection).request(Methods.pruneImages, opts)
  },

  tagImage(id, repo, tag = 'latest', connection) {
    return connOrActive(connection).request(Methods.tagImage, { id, repo, tag })
  },

  buildImage(args, connection) {
    return connOrActive(connection).request(Methods.buildImage, args)
  },

  pushImage(image, opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    const body =
      typeof image === 'object' && image
        ? { ...image }
        : { image, id: opts.id || image, ...opts }
    return connOrActive(connection).request(Methods.pushImage, body)
  },

  saveImage(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.saveImage, { id, ...opts })
  },

  loadImageStart(connection) {
    return connOrActive(connection).request(Methods.loadImageStart, {})
  },

  loadImageChunk(transferId, data, opts = {}, connection) {
    return connOrActive(connection).request(Methods.loadImageChunk, {
      transferId,
      data,
      ...opts,
    })
  },

  loadImageFinish(transferId, connection) {
    return connOrActive(connection).request(Methods.loadImageFinish, { transferId })
  },

  importImage(data, opts = {}, connection) {
    return connOrActive(connection).request(Methods.importImage, { data, ...opts })
  },

  pruneBuilder(connection) {
    return connOrActive(connection).request(Methods.pruneBuilder, {})
  },

  systemPrune(opts = {}, connection) {
    return connOrActive(connection).request(Methods.systemPrune, opts)
  },

  recreateContainer(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.recreateContainer, { id, ...opts })
  },

  browseVolume(name, path = '/', connection) {
    return connOrActive(connection).request(Methods.browseVolume, { name, path })
  },

  listSchedules(connection) {
    return connOrActive(connection).request(Methods.listSchedules, {})
  },

  upsertSchedule(args, connection) {
    return connOrActive(connection).request(Methods.upsertSchedule, args)
  },

  deleteSchedule(id, connection) {
    return connOrActive(connection).request(Methods.deleteSchedule, { id })
  },

  scaleService(id, replicas, connection) {
    return connOrActive(connection).request(Methods.scaleService, { id, replicas })
  },

  updateContainer(args, connection) {
    return connOrActive(connection).request(Methods.updateContainer, args)
  },

  // —— Networks / volumes ——
  listNetworks(connection) {
    return connOrActive(connection).request(Methods.listNetworks, {})
  },

  createNetwork(args, connection) {
    return connOrActive(connection).request(Methods.createNetwork, args)
  },

  removeNetwork(id, connection) {
    return connOrActive(connection).request(Methods.removeNetwork, { id })
  },

  pruneNetworks(opts = {}, connection) {
    return connOrActive(connection).request(Methods.pruneNetworks, opts)
  },

  listVolumes(connection) {
    return connOrActive(connection).request(Methods.listVolumes, {})
  },

  createVolume(args, connection) {
    return connOrActive(connection).request(Methods.createVolume, args)
  },

  removeVolume(name, connection) {
    return connOrActive(connection).request(Methods.removeVolume, { name })
  },

  pruneVolumes(opts = {}, connection) {
    return connOrActive(connection).request(Methods.pruneVolumes, opts)
  },

  // —— Stacks ——
  listStacks(connection) {
    return connOrActive(connection).request(Methods.listStacks, {})
  },

  deployStack(composeContent, stackName, opts = {}, connection) {
    // opts may be a connection when called as (content, name, connection)
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    return connOrActive(connection).request(Methods.deployStack, {
      composeContent,
      stackName,
      ...opts,
    })
  },

  removeStack(stackName, connection) {
    return connOrActive(connection).request(Methods.removeStack, { stackName })
  },

  stackPs(stackName, connection) {
    return connOrActive(connection).request(Methods.stackPs, { stackName })
  },

  stackLogs(stackName, opts = {}, connection) {
    return connOrActive(connection).request(Methods.stackLogs, { stackName, ...opts })
  },

  stackPull(stackName, opts = {}, connection) {
    return connOrActive(connection).request(Methods.stackPull, { stackName, ...opts })
  },

  // —— System ——
  getSystemInfo(connection) {
    return connOrActive(connection).request(Methods.getSystemInfo, {})
  },

  getSystemDf(connection) {
    return connOrActive(connection).request(Methods.getSystemDf, {})
  },

  getDockerEvents(opts = {}, connection) {
    return connOrActive(connection).request(Methods.getDockerEvents, opts)
  },

  registryLogin(args, connection) {
    return connOrActive(connection).request(Methods.registryLogin, args)
  },

  registryLogout(connection) {
    return connOrActive(connection).request(Methods.registryLogout, {})
  },

  getAuthStatus(connection) {
    return connOrActive(connection).request(Methods.getAuthStatus, {})
  },

  getMetrics(connection) {
    return connOrActive(connection).request(Methods.getMetrics, {})
  },

  getHostSnapshot(connection) {
    return connOrActive(connection).request(Methods.getHostSnapshot, {})
  },

  suggestNetworkIPAM(opts = {}, connection) {
    return connOrActive(connection).request(Methods.suggestNetworkIPAM, opts)
  },

  suggestResourceName(kind, base, connection) {
    return connOrActive(connection).request(Methods.suggestResourceName, { kind, base })
  },

  suggestFromImage(image, connection) {
    return connOrActive(connection).request(Methods.suggestFromImage, { image })
  },

  suggestDefaults(kind, args = {}, connection) {
    return connOrActive(connection).request(Methods.suggestDefaults, { kind, ...args })
  },

  getStatsHistory(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.getStatsHistory, { id, ...opts })
  },

  getContainerLogs(id, opts = {}, connection) {
    return connOrActive(connection).request(Methods.getContainerLogs, { id, ...opts })
  },

  createContainer(args, connection) {
    return connOrActive(connection).request(Methods.createContainer, args)
  },

  // —— Vault / peers ——
  listVaultCredentials(connection) {
    return connOrActive(connection).request(Methods.listVaultCredentials, {})
  },

  vaultStoreCredential(args, connection) {
    return connOrActive(connection).request(Methods.vaultStoreCredential, args)
  },

  vaultDeleteCredential(id, connection) {
    return connOrActive(connection).request(Methods.vaultDeleteCredential, { id })
  },

  vaultUseCredential(id, connection) {
    return connOrActive(connection).request(Methods.vaultUseCredential, { id })
  },

  vaultTestCredential(args, connection) {
    return connOrActive(connection).request(Methods.vaultTestCredential, args)
  },

  vaultClearSession(connection) {
    return connOrActive(connection).request(Methods.vaultClearSession, {})
  },

  listPeers(connection) {
    return connOrActive(connection).request(Methods.listPeers, {})
  },

  invitePeer(args = {}, connection) {
    return connOrActive(connection).request(Methods.invitePeer, args)
  },

  deleteInvite(args = {}, connection) {
    return connOrActive(connection).request(Methods.deleteInvite, args)
  },

  revokePeer(peerId, connection) {
    return connOrActive(connection).request(Methods.revokePeer, { peerId })
  },

  unrevokePeer(peerId, connection) {
    return connOrActive(connection).request(Methods.unrevokePeer, { peerId })
  },

  clearRevokedPeers(connection) {
    return connOrActive(connection).request(Methods.clearRevokedPeers, {})
  },

  listRevokedPeers(connection) {
    return connOrActive(connection).request(Methods.listRevokedPeers, {})
  },

  setPeerRole(peerId, role, connection) {
    return connOrActive(connection).request(Methods.setPeerRole, { peerId, role })
  },

  listInvites(connection) {
    return connOrActive(connection).request(Methods.listInvites, {})
  },

  syncStackFromGit(args, connection) {
    return connOrActive(connection).request(Methods.syncStackFromGit, args)
  },

  // —— Holesail tunnels (on by default; ENABLE_HOLESAIL=0 to disable) ——
  listTunnels(connection) {
    return connOrActive(connection).request(Methods.listTunnels, {})
  },

  getHolesailStatus(connection) {
    return connOrActive(connection).request(Methods.getHolesailStatus, {})
  },

  createTunnel(args, connection) {
    return connOrActive(connection).request(Methods.createTunnel, args)
  },

  closeTunnel(id, connection) {
    return connOrActive(connection).request(Methods.closeTunnel, { id })
  },

  // —— Swarm (on by default; ENABLE_SWARM=0 to disable) ——
  swarmInspect(connection) {
    return connOrActive(connection).request(Methods.swarmInspect, {})
  },

  listServices(opts = {}, connection) {
    return connOrActive(connection).request(Methods.listServices, opts)
  },

  listNodes(opts = {}, connection) {
    return connOrActive(connection).request(Methods.listNodes, opts)
  },

  // —— Streams ——
  startTerminal(containerId, opts = {}, connection) {
    if (opts && typeof opts.request === 'function') {
      connection = opts
      opts = {}
    }
    return connOrActive(connection).request(Methods.startTerminal, {
      containerId,
      ...opts,
    })
  },

  killTerminal(containerId, connection) {
    return connOrActive(connection).request(Methods.killTerminal, { containerId })
  },

  terminalInput(payload, connection) {
    return connOrActive(connection).event(Methods.terminalInput, payload)
  },

  terminalResize(payload, connection) {
    return connOrActive(connection).event(Methods.terminalResize, payload)
  },

  startLogs(id, connection) {
    return connOrActive(connection).request(Methods.startLogs, { id })
  },

  stopLogs(id, connection) {
    return connOrActive(connection).request(Methods.stopLogs, { id })
  },

  dockerCommand(data, connectionId, connection) {
    return connOrActive(connection).request(Methods.dockerCommand, { data, connectionId })
  },

  /** Generic escape hatch */
  request(method, args = {}, connection) {
    return connOrActive(connection).request(method, args)
  },

  event(method, args = {}, connection) {
    return connOrActive(connection).event(method, args)
  },
}

export default api