@reset-framework/sdk 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reset-framework/sdk",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "type": "module",
   "description": "Browser-side SDK for Reset Framework applications.",
   "license": "MIT",

package/src/client.js

@@ -193,6 +193,32 @@ function normalizeProtocolInfo(payload, command) {
   })
 }
 
+function normalizeBackendInfo(payload, command) {
+  const record = requireObject(payload, command)
+  const runtime = isObjectLike(record.runtime) ? record.runtime : {}
+
+  return Object.freeze({
+    supported: requireBooleanField(record, "supported", command),
+    configured: requireBooleanField(record, "configured", command),
+    running: requireBooleanField(record, "running", command),
+    available: requireBooleanField(record, "available", command),
+    protocol: requireStringField(record, "protocol", command),
+    pid: typeof record.pid === "number" ? record.pid : null,
+    entryPath: optionalStringField(record, "entryPath", "", command),
+    runnerPath: optionalStringField(record, "runnerPath", "", command),
+    executablePath: optionalStringField(record, "executablePath", "", command),
+    workingDirectory: optionalStringField(record, "workingDirectory", "", command),
+    methods: normalizeStringArray(record.methods ?? [], "methods", command),
+    runtime: Object.freeze({
+      name: optionalStringField(runtime, "name", "", command),
+      version: optionalStringField(runtime, "version", "", command),
+      platform: optionalStringField(runtime, "platform", "", command),
+      arch: optionalStringField(runtime, "arch", "", command)
+    }),
+    lastError: optionalStringField(record, "lastError", "", command)
+  })
+}
+
 function createCommandApi(transport) {
   return Object.freeze({
     invoke(command, payload = {}) {
@@ -717,6 +743,63 @@ function createNetApi(transport) {
   })
 }
 
+function createBackendApi(transport, events) {
+  const normalizeEventName = (eventName) => {
+    if (typeof eventName !== "string" || eventName.trim() === "") {
+      throw new TypeError("Reset backend event name must be a non-empty string.")
+    }
+
+    return eventName.startsWith("backend.") ? eventName : `backend.${eventName}`
+  }
+
+  const invokeBackend = (method, params = {}) =>
+    transport.invoke("backend.invoke", {
+      method,
+      params
+    })
+
+  const processApi = Object.freeze({
+    spawn(options) {
+      return invokeBackend("process.spawn", options)
+    },
+    run(options) {
+      return invokeBackend("process.run", options)
+    },
+    write(processId, data) {
+      return invokeBackend("process.write", { processId, data })
+    },
+    kill(processId, options = {}) {
+      return invokeBackend("process.kill", {
+        processId,
+        ...options
+      })
+    },
+    list() {
+      return invokeBackend("process.list", {})
+    }
+  })
+
+  return Object.freeze({
+    async getInfo() {
+      return normalizeBackendInfo(await transport.invoke("backend.getInfo"), "backend.getInfo")
+    },
+    async isAvailable() {
+      const info = await transport.invoke("backend.getInfo")
+      return normalizeBackendInfo(info, "backend.getInfo").available
+    },
+    invoke(method, params = {}) {
+      return invokeBackend(method, params)
+    },
+    listen(eventName, handler) {
+      return events.listen(normalizeEventName(eventName), handler)
+    },
+    once(eventName, handler) {
+      return events.once(normalizeEventName(eventName), handler)
+    },
+    process: processApi
+  })
+}
+
 function scheduleFrontendReadySignal(transport) {
   const target = typeof globalThis === "object" ? globalThis.window : undefined
 
@@ -775,6 +858,7 @@ export function createResetClient(source) {
   const protocol = createProtocolApi(transport, events)
   const updater = createUpdaterApi(transport)
   const net = createNetApi(transport)
+  const backend = createBackendApi(transport, events)
   const client = Object.freeze({
     isAvailable() {
       return transport.isAvailable()
@@ -804,7 +888,8 @@ export function createResetClient(source) {
     shortcut,
     protocol,
     updater,
-    net
+    net,
+    backend
   })
 
   scheduleFrontendReadySignal(transport)
@@ -844,3 +929,4 @@ export const shortcut = reset.shortcut
 export const protocol = reset.protocol
 export const updater = reset.updater
 export const net = reset.net
+export const backend = reset.backend

package/src/index.d.ts

@@ -319,6 +319,94 @@ export interface ResetProcessApi {
   getInfo(): Promise<ResetProcessInfo>;
 }
 
+export interface ResetBackendRuntimeInfo {
+  name: string;
+  version: string;
+  platform: string;
+  arch: string;
+}
+
+export interface ResetBackendInfo {
+  supported: boolean;
+  configured: boolean;
+  running: boolean;
+  available: boolean;
+  protocol: string;
+  pid: number | null;
+  entryPath: string;
+  runnerPath: string;
+  executablePath: string;
+  workingDirectory: string;
+  methods: ReadonlyArray<string>;
+  runtime: ResetBackendRuntimeInfo;
+  lastError: string;
+}
+
+export interface ResetBackendProcessInfo {
+  id: string;
+  pid: number;
+  command: string;
+  args: string[];
+  cwd: string;
+  running: boolean;
+  startedAt: string;
+}
+
+export interface ResetBackendProcessRunOptions {
+  command: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  shell?: boolean;
+  input?: string;
+  timeoutMs?: number;
+  maxBufferBytes?: number;
+}
+
+export interface ResetBackendProcessRunResult {
+  command: string;
+  args: string[];
+  cwd: string;
+  exitCode: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+  failed: boolean;
+}
+
+export interface ResetBackendProcessApi {
+  spawn(options: {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    shell?: boolean;
+  }): Promise<ResetBackendProcessInfo>;
+  run(options: ResetBackendProcessRunOptions): Promise<ResetBackendProcessRunResult>;
+  write(processId: string, data: string): Promise<{ written: boolean }>;
+  kill(
+    processId: string,
+    options?: { signal?: string }
+  ): Promise<{ killed: boolean }>;
+  list(): Promise<{ processes: ResetBackendProcessInfo[] }>;
+}
+
+export interface ResetBackendApi {
+  getInfo(): Promise<ResetBackendInfo>;
+  isAvailable(): Promise<boolean>;
+  invoke<TResult = unknown>(method: string, params?: unknown): Promise<TResult>;
+  listen<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  once<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  process: ResetBackendProcessApi;
+}
+
 export interface ResetPowerInfo {
   supported: boolean;
   lowPowerMode: boolean;
@@ -473,6 +561,7 @@ export interface ResetClient {
   protocol: ResetProtocolApi;
   updater: ResetUpdaterApi;
   net: ResetNetApi;
+  backend: ResetBackendApi;
 }
 
 export interface ResetEventApi {
@@ -572,3 +661,4 @@ export const shortcut: ResetShortcutApi;
 export const protocol: ResetProtocolApi;
 export const updater: ResetUpdaterApi;
 export const net: ResetNetApi;
+export const backend: ResetBackendApi;

package/src/index.js

@@ -1,5 +1,6 @@
 export {
   app,
+  backend,
   clipboard,
   commands,
   createResetClient,