@electric-ax/agents-server 0.4.12 → 0.4.14

package/src/stream-client.ts

@@ -225,7 +225,7 @@ export class StreamClient {
 
   async create(
     path: string,
-    opts: { contentType: string; body?: Uint8Array | string }
+    opts: { contentType: string; body?: Uint8Array | string; closed?: boolean }
   ): Promise<void> {
     return await withSpan(`stream.create`, async (span) => {
       span.setAttributes({
@@ -237,6 +237,7 @@ export class StreamClient {
         headers: this.streamHeaders(),
         contentType: opts.contentType,
         body: opts.body,
+        closed: opts.closed,
       })
     })
   }
@@ -368,38 +369,18 @@ export class StreamClient {
         offset: fromOffset ?? `-1`,
         live: false,
       })
-      const messages: Array<StreamMessage> = []
-
-      return await new Promise<StreamReadResult>((resolve, reject) => {
-        let settled = false
-        let unsub = () => {}
-
-        const finish = (r: StreamReadResult) => {
-          if (settled) return
-          settled = true
-          unsub()
-          resolve(r)
-        }
-
-        unsub = response.subscribeBytes((chunk) => {
-          messages.push({
-            data: chunk.data,
-            offset: chunk.offset,
-          })
-          if (chunk.upToDate || chunk.streamClosed) {
-            finish({ messages })
-          }
-        })
-
-        response.closed
-          .then(() => finish({ messages }))
-          .catch((err) => {
-            if (settled) return
-            settled = true
-            unsub()
-            reject(err)
-          })
-      })
+      const body = await response.body()
+      return {
+        messages:
+          body.length === 0
+            ? []
+            : [
+                {
+                  data: body,
+                  offset: response.offset,
+                },
+              ],
+      }
     })
   }
 

package/src/utils/log.ts

@@ -8,62 +8,73 @@ const USE_FILE_LOGS = process.env.ELECTRIC_AGENTS_LOG_FILE !== `false`
 const USE_PRETTY_LOGS =
   LOG_LEVEL !== `silent` && !process.env.VITEST && !IS_ELECTRON_MAIN
 
-const LOG_DIR = USE_FILE_LOGS
-  ? (process.env.ELECTRIC_AGENTS_LOG_DIR ?? path.resolve(process.cwd(), `logs`))
-  : undefined
-const LOG_FILE = LOG_DIR
-  ? path.join(LOG_DIR, `agent-server-${Date.now()}.jsonl`)
-  : undefined
+let _logger: pino.Logger | undefined
 
-if (LOG_DIR) {
-  fs.mkdirSync(LOG_DIR, { recursive: true })
-}
+function getLogger(): pino.Logger {
+  if (_logger) return _logger
 
-export const LOG_FILE_PATH = LOG_FILE
+  const streams: Array<pino.StreamEntry> = []
 
-const streams: Array<pino.StreamEntry> = []
-if (LOG_FILE) {
-  streams.push({
-    stream: pino.destination({
-      dest: LOG_FILE,
-      sync: IS_ELECTRON_MAIN,
-    }),
-  })
-}
-if (USE_PRETTY_LOGS) {
-  streams.push({
-    stream: pino.transport({
-      target: `pino-pretty`,
-      options: {
-        colorize: true,
-        ignore: `pid,hostname,name`,
-        translateTime: `SYS:HH:MM:ss`,
-      },
-    }),
-  })
-}
+  try {
+    if (USE_FILE_LOGS) {
+      const logDir =
+        process.env.ELECTRIC_AGENTS_LOG_DIR ??
+        path.resolve(process.cwd(), `logs`)
+      fs.mkdirSync(logDir, { recursive: true })
+      const logFile = path.join(logDir, `agent-server-${Date.now()}.jsonl`)
+      streams.push({
+        stream: pino.destination({
+          dest: logFile,
+          sync: IS_ELECTRON_MAIN,
+        }),
+      })
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[agents-server] Failed to initialize file logging: ${err instanceof Error ? err.message : err}\n`
+    )
+  }
 
-const logger =
-  streams.length > 0
-    ? pino(
-        {
+  try {
+    if (USE_PRETTY_LOGS) {
+      streams.push({
+        stream: pino.transport({
+          target: `pino-pretty`,
+          options: {
+            colorize: true,
+            ignore: `pid,hostname,name`,
+            translateTime: `SYS:HH:MM:ss`,
+          },
+        }),
+      })
+    }
+  } catch {
+    // pino-pretty unavailable — continue without pretty logging
+  }
+
+  _logger =
+    streams.length > 0
+      ? pino(
+          {
+            base: undefined,
+            level: LOG_LEVEL,
+          },
+          pino.multistream(streams)
+        )
+      : pino({
           base: undefined,
+          enabled: false,
           level: LOG_LEVEL,
-        },
-        pino.multistream(streams)
-      )
-    : pino({
-        base: undefined,
-        enabled: false,
-        level: LOG_LEVEL,
-      })
+        })
+  return _logger
+}
 
 function formatArgs(args: Array<unknown>): { err?: Error; msg: string } {
   const errors: Array<Error> = []
   const parts: Array<string> = []
-  for (const a of args) {
-    if (a instanceof Error) errors.push(a)
-    else parts.push(typeof a === `string` ? a : JSON.stringify(a))
+  for (const value of args) {
+    if (value instanceof Error) errors.push(value)
+    else parts.push(typeof value === `string` ? value : JSON.stringify(value))
   }
   return {
     err: errors[0],
@@ -74,22 +85,22 @@ function formatArgs(args: Array<unknown>): { err?: Error; msg: string } {
 export const serverLog = {
   info(...args: Array<unknown>): void {
     const { msg } = formatArgs(args)
-    logger.info(msg)
+    getLogger().info(msg)
   },
 
   warn(...args: Array<unknown>): void {
     const { err, msg } = formatArgs(args)
-    if (err) logger.warn({ err }, msg)
-    else logger.warn(msg)
+    if (err) getLogger().warn({ err }, msg)
+    else getLogger().warn(msg)
   },
 
   error(...args: Array<unknown>): void {
     const { err, msg } = formatArgs(args)
-    if (err) logger.error({ err }, msg)
-    else logger.error(msg)
+    if (err) getLogger().error({ err }, msg)
+    else getLogger().error(msg)
   },
 
   event(obj: Record<string, unknown>, msg: string): void {
-    logger.info(obj, msg)
+    getLogger().info(obj, msg)
   },
 }