CameraManager

CameraManager API — camera discovery, connection lifecycle, BoundCamera accessor, per-camera events, connectAll, discover, and reconnection for the TypeScript Client SDK

CameraManager is the entry point for the Client SDK. It replaces the manual ServerManager + CameraClient + EventStream workflow — one class handles binary management, camera discovery, connection lifecycle, SSE events, and reconnection.

Server (Node.js)

Import from camera-remote-web-api/server. This variant spawns and manages the native binary.

import { CameraManager } from 'camera-remote-web-api/server';

const manager = new CameraManager({ port: 8080 });

manager.on('camera-ready', async ({ cameraId, camera }) => {
  console.log(`${camera.model} connected`);
  const cam = manager.camera(cameraId);
  await cam.setPriorityKey({ setting: 'pc-remote' });
  await cam.triggerShutter();
});

await manager.start();

Browser

Import from camera-remote-web-api (the default export). Connects to an already-running server — no binary management.

import { CameraManager } from 'camera-remote-web-api';

const manager = new CameraManager({
  baseUrl: 'http://localhost:8080',
});

manager.on('camera-ready', ({ cameraId, camera }) => {
  console.log(`${camera.model} ready`);
});

manager.start();  // Synchronous — just starts polling + SSE

Use manager.camera(cameraId) to get a bound camera object with all methods pre-bound — no need to pass the camera ID to every call. For direct access, manager.client is also available as a full CameraClient instance. See Properties & Actions.

---

Options

const manager = new CameraManager({
  // Server options (server variant only)
  port: 8080,              // Default: 8080
  autoPort: true,          // Find next available port if busy
  binaryPath: '/path/to', // Explicit path to CameraWebApp binary

  // Connection options (all variants)
  baseUrl: 'http://localhost:8080', // Server URL (browser variant only)
  autoConnect: true,       // Auto-connect discovered cameras (default: true)
  connectionMode: 'remote-transfer', // Default: 'remote'
  autoReconnect: true,     // Reconnect on unexpected disconnect (default: true)
  maxReconnectAttempts: 5, // Give up after N attempts (default: 5)
  pollInterval: 5000,      // Camera discovery interval in ms (default: 5000)
});

Option	Default	Description
port	8080	Server port (server only)
autoPort	false	Find next available port if busy (server only)
binaryPath	auto-detected	Explicit binary path (server only, required in Next.js)
baseUrl	http://localhost:8080	Server URL (browser only)
autoConnect	true	Connect cameras automatically on discovery
connectionMode	'remote'	Default connection mode for auto-connect
autoReconnect	true	Reconnect on unexpected disconnect
maxReconnectAttempts	5	Max reconnect attempts before giving up
pollInterval	5000	Camera discovery polling interval (ms)

---

Connection Modes

The connection mode determines what operations are available on a connected camera.

Mode	Description
remote	Full camera control. Photos auto-transfer to host PC.
remote-transfer	Full camera control + explicit SD card file download.
contents	SD card browsing and file download only — no shooting or settings.

Not all cameras support all modes or APIs. See Compatibility for per-camera details.

Choosing a mode

I want to shoot and auto-save photos to my computer

Use remote. Set still-image-store-destination to 0x1 (Host PC) or 0x3 (Both) for auto-transfer. Listen for downloadComplete events to know when files are saved.

I want to shoot AND browse the SD card

Use remote-transfer. You get full shooting control plus explicit file listing and download from the SD card. This is the most flexible mode.

I only need to download files from the SD card

Use contents. No shooting or settings control — just file browsing and download.

// Set mode globally
const manager = new CameraManager({ connectionMode: 'remote-transfer' });

// Or per-camera when using manual connection
await manager.connect(camera.id, { mode: 'remote-transfer' });

---

Lifecycle

// Start — boots binary (server), begins polling, subscribes to SSE
await manager.start();

// Get a bound camera — all methods pre-bound with the camera ID
const cam = manager.camera(cameraId);
await cam.setProperty('iso', { value: '400' });

// Or use the underlying client directly
await manager.client.setProperty(cameraId, 'iso', { value: '400' });

// Stop — closes SSE, stops polling, kills binary (server)
await manager.close();

Discovery & batch connection

// Trigger immediate discovery (useful when autoConnect is off)
const cameras = await manager.discover();

// Connect all detected cameras in parallel
await manager.connectAll({ mode: 'remote-transfer' });

Server-only methods

These are only available on the server variant (camera-remote-web-api/server):

manager.getPort();           // Current port (may differ if autoPort)
await manager.isRunning();   // Binary health check
manager.getPid();            // Binary process ID
manager.getStdout();         // Binary stdout lines
manager.getStderr();         // Binary stderr lines

---

Camera Access

// All cameras with state
const cameras = manager.getCameras();
// → [{ info: { id, model, connectionType, connected }, state: 'connected', reconnectAttempts: 0 }]

// Single camera by ID
const cam = manager.getCamera('D10F60149B0C');
// → { info: {...}, state: 'connected', reconnectAttempts: 0 }

---

Bound Camera Accessor

manager.camera(id) returns a BoundCamera object with all CameraClient methods pre-bound with the camera ID. This is the recommended way to interact with cameras — it eliminates the need to thread the camera ID through every call.

const cam = manager.camera('D10F60149B0C');

// No cameraId parameter needed
await cam.setPriorityKey({ setting: 'pc-remote' });
await cam.triggerShutter();
const iso = await cam.getProperty('iso');
console.log(iso.data.formatted);  // "ISO 400"

// Per-camera SSE events via .events
cam.events.on('downloadComplete', (data) => {
  console.log('Saved:', data.filename);
});

// One-shot listener — auto-removed after first fire
cam.events.once('transferProgress', (data) => {
  console.log('First transfer:', data.filename);
});

Bound cameras are lazily created and cached — calling manager.camera(id) multiple times returns the same object.

Available methods

All CameraClient methods are available without the camera ID parameter:

Category	Methods
Connection	connect(), disconnect(), getConnectionStatus()
Properties	getProperty(), setProperty(), getAllProperties(), getPriorityKey(), setPriorityKey()
Actions	triggerShutter(), halfPress(), afShutter(), controlZoom(), stopZoom(), focusNearFar()
Live View	enableLiveView(), disableLiveView(), getLiveViewStatus(), startLiveViewStream(), stopLiveViewStream(), getLiveViewFrame()
OSD	enableOSD(), disableOSD(), getOSDStatus(), getOSDFrame()
SD Card	listSDCardFiles(), downloadSDCardFile()
Settings	getSaveInfo(), setSaveInfo(), downloadCameraSettings(), uploadCameraSettings(), listSettingsFiles()

Per-camera events

The events property returns a CameraEventStream — a typed SSE client scoped to that camera.

const cam = manager.camera(cameraId);

cam.events.on('propertyChanged', (data) => {
  console.log('Changed:', data.codes);
});

cam.events.on('warning', (data) => {
  if (data.code === '0x20011') console.log('Photo captured!');
});

// Cleanup
cam.events.close();

Method	Description
on(event, callback)	Subscribe to events
off(event, callback?)	Unsubscribe
once(event, callback)	One-shot listener — auto-removed after first fire
close()	Close SSE connection
connected	Whether SSE is connected (read-only)

---

Manual Connection Control

For full manual control over connection lifecycle — connecting specific cameras, managing state transitions, and handling reconnection yourself — use the stateful API classes directly instead of CameraManager.

Stateful API Access

Direct access to CameraClient, EventStream, and ServerManager without CameraManager automation