@northflare/runner 0.0.8 → 0.0.10

package/src/utils/logger.ts

@@ -4,6 +4,7 @@
 
 import winston from "winston";
 import path from "path";
+import { isRunnerDebugEnabled } from "./debug";
 
 // Custom log levels
 const levels = {
@@ -29,6 +30,8 @@ const colors = {
 
 winston.addColors(colors);
 
+const debugEnabled = isRunnerDebugEnabled();
+
 // Format for console output
 const consoleFormat = winston.format.combine(
   winston.format.colorize({ all: true }),
@@ -36,7 +39,7 @@ const consoleFormat = winston.format.combine(
   winston.format.printf(({ timestamp, level, message, stack, ...metadata }) => {
     let msg = `${timestamp} [${level}]: ${message}`;
     // Only show stack traces and metadata in debug mode
-    if (process.env["DEBUG"] === "true") {
+    if (debugEnabled) {
       if (stack) {
         msg += `\n${stack}`;
       }
@@ -59,13 +62,13 @@ const fileFormat = winston.format.combine(
 
 // Create logger instance
 export const logger = winston.createLogger({
-  level: process.env["DEBUG"] === "true" ? "debug" : "info",
+  level: debugEnabled ? "debug" : "info",
   levels,
   transports: [
     // Always include console transport for errors
     new winston.transports.Console({
       format: consoleFormat,
-      level: process.env["DEBUG"] === "true" ? "debug" : "error",
+      level: debugEnabled ? "debug" : "error",
     }),
   ],
 });
@@ -94,7 +97,7 @@ export function configureFileLogging(logDir: string): void {
   );
 
   // Debug log file (only in debug mode)
-  if (process.env["DEBUG"] === "true") {
+  if (debugEnabled) {
     logger.add(
       new winston.transports.File({
         filename: path.join(logDir, "debug.log"),
@@ -128,4 +131,4 @@ logger.rejections.handle(
 );
 
 // Export default logger
-export default logger;
+export default logger;

package/src/utils/model.ts

@@ -0,0 +1,29 @@
+export type ModelReasoningEffort = "low" | "medium" | "high";
+
+const REASONING_VALUES: readonly ModelReasoningEffort[] = [
+  "low",
+  "medium",
+  "high",
+];
+
+export function parseModelValue(value?: string | null): {
+  baseModel?: string;
+  reasoningEffort?: ModelReasoningEffort;
+} {
+  if (!value) {
+    return {};
+  }
+
+  const [model, possibleEffort] = value.split(":");
+  if (
+    possibleEffort &&
+    REASONING_VALUES.includes(possibleEffort as ModelReasoningEffort)
+  ) {
+    return {
+      baseModel: model,
+      reasoningEffort: possibleEffort as ModelReasoningEffort,
+    };
+  }
+
+  return { baseModel: value };
+}

package/src/utils/status-line.ts

@@ -1,11 +1,12 @@
 /**
- * StatusLineManager - Manages persistent status line output for active Claude Code processes
- * 
+ * StatusLineManager - Manages persistent status line output for active agent processes
+ *
  * This component maintains a single-line status output that updates every minute to show
- * the count of active Claude Code processes. It prevents the machine from entering idle
+ * the count of active agent processes. It prevents the machine from entering idle
  * state while processes are running and provides clear visual feedback without cluttering
  * the terminal with multiple log lines.
  */
+import { isRunnerDebugEnabled } from "./debug";
 
 export class StatusLineManager {
   private intervalId?: NodeJS.Timeout;
@@ -15,7 +16,7 @@ export class StatusLineManager {
 
   constructor() {
     // Only enable status line when not in debug mode
-    this.isEnabled = process.env["DEBUG"] !== "true";
+    this.isEnabled = !isRunnerDebugEnabled();
   }
 
   /**
@@ -84,11 +85,11 @@ export class StatusLineManager {
 
     let newLine: string;
     if (this.activeCount === 0) {
-      newLine = "No active Claude Code processes";
+      newLine = "No active agent processes";
     } else if (this.activeCount === 1) {
-      newLine = `${timeStr} 1 active Claude Code process`;
+      newLine = `${timeStr} 1 active agent process`;
     } else {
-      newLine = `${timeStr} ${this.activeCount} active Claude Code processes`;
+      newLine = `${timeStr} ${this.activeCount} active agent processes`;
     }
 
     // If this is the first status line, position it
@@ -118,4 +119,4 @@ export class StatusLineManager {
 }
 
 // Singleton instance
-export const statusLineManager = new StatusLineManager();
+export const statusLineManager = new StatusLineManager();

package/src/utils/tool-response-sanitizer.ts

@@ -0,0 +1,160 @@
+export const TOOL_RESPONSE_BYTE_LIMIT = 500 * 1024; // 500 KiB cap per tool response payload
+export const TOOL_RESPONSE_SUFFIX = "... [truncated]";
+
+export interface ToolResponseSanitizationResult {
+  params: any;
+  truncated: boolean;
+  toolUseId?: string;
+}
+
+interface TruncationContext {
+  bytesRemaining: number;
+  truncated: boolean;
+}
+
+export function sanitizeToolResponsePayload(
+  method: string | undefined,
+  params: any
+): ToolResponseSanitizationResult {
+  if (method !== "message.agent" || !params) {
+    return { params, truncated: false };
+  }
+
+  if (!isToolResultPayload(params)) {
+    return { params, truncated: false };
+  }
+
+  const context: TruncationContext = {
+    bytesRemaining: TOOL_RESPONSE_BYTE_LIMIT,
+    truncated: false,
+  };
+
+  const [sanitized, changed] = truncateStringsRecursively(params, context);
+
+  if (!changed && !context.truncated) {
+    return { params, truncated: false };
+  }
+
+  return {
+    params: sanitized,
+    truncated: true,
+    toolUseId: extractToolUseId(params),
+  };
+}
+
+function isToolResultPayload(payload: any): boolean {
+  if (!payload) {
+    return false;
+  }
+  if (payload.type === "tool_result" || payload.subtype === "tool_result") {
+    return true;
+  }
+  if (Array.isArray(payload.content)) {
+    return payload.content.some((entry: any) => isToolResultBlock(entry));
+  }
+  return isToolResultBlock(payload.content);
+}
+
+function isToolResultBlock(block: any): boolean {
+  if (!block) {
+    return false;
+  }
+  return (
+    block.type === "tool_result" ||
+    block.subtype === "tool_result" ||
+    typeof block.tool_use_id === "string"
+  );
+}
+
+function extractToolUseId(payload: any): string | undefined {
+  if (!payload) {
+    return undefined;
+  }
+  if (typeof payload.tool_use_id === "string") {
+    return payload.tool_use_id;
+  }
+  if (Array.isArray(payload.content)) {
+    const match = payload.content.find(
+      (entry: any) => entry && typeof entry.tool_use_id === "string"
+    );
+    if (match) {
+      return match.tool_use_id;
+    }
+  }
+  if (payload.content && typeof payload.content === "object") {
+    return extractToolUseId(payload.content);
+  }
+  return undefined;
+}
+
+function truncateStringsRecursively(
+  value: any,
+  context: TruncationContext
+): [any, boolean] {
+  if (typeof value === "string") {
+    return truncateStringValue(value, context);
+  }
+
+  if (Array.isArray(value)) {
+    let mutated = false;
+    let result: any[] = value;
+    for (let i = 0; i < value.length; i++) {
+      const [newItem, changed] = truncateStringsRecursively(value[i], context);
+      if (changed) {
+        if (!mutated) {
+          result = value.slice();
+          mutated = true;
+        }
+        result[i] = newItem;
+      }
+    }
+    return [result, mutated];
+  }
+
+  if (value && typeof value === "object") {
+    let mutated = false;
+    let result: Record<string, any> = value;
+    for (const key of Object.keys(value)) {
+      const [newVal, changed] = truncateStringsRecursively(
+        value[key],
+        context
+      );
+      if (changed) {
+        if (!mutated) {
+          result = { ...value };
+          mutated = true;
+        }
+        result[key] = newVal;
+      }
+    }
+    return [result, mutated];
+  }
+
+  return [value, false];
+}
+
+function truncateStringValue(
+  value: string,
+  context: TruncationContext
+): [string, boolean] {
+  if (context.bytesRemaining <= 0) {
+    if (value.length === 0) {
+      return [value, false];
+    }
+    context.truncated = true;
+    return ["", true];
+  }
+
+  const byteLength = Buffer.byteLength(value, "utf8");
+  if (byteLength <= context.bytesRemaining) {
+    context.bytesRemaining -= byteLength;
+    return [value, false];
+  }
+
+  const suffixBytes = Buffer.byteLength(TOOL_RESPONSE_SUFFIX, "utf8");
+  const maxBytes = Math.max(0, context.bytesRemaining - suffixBytes);
+  const truncatedBuffer = Buffer.from(value, "utf8").subarray(0, maxBytes);
+  context.bytesRemaining = 0;
+  context.truncated = true;
+  return [truncatedBuffer.toString("utf8") + TOOL_RESPONSE_SUFFIX, true];
+}

package/tests/tool-response-sanitizer.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import {
+  sanitizeToolResponsePayload,
+  TOOL_RESPONSE_BYTE_LIMIT,
+  TOOL_RESPONSE_SUFFIX,
+} from "../src/utils/tool-response-sanitizer";
+
+describe("sanitizeToolResponsePayload", () => {
+  it("returns original params for non message.agent notifications", () => {
+    const payload = { type: "tool_result", content: [] };
+    const result = sanitizeToolResponsePayload("runner.heartbeat", payload);
+    expect(result.truncated).toBe(false);
+    expect(result.params).toBe(payload);
+  });
+
+  it("truncates oversized tool_result strings", () => {
+    const longText = "x".repeat(TOOL_RESPONSE_BYTE_LIMIT + 128);
+    const payload = {
+      type: "tool_result",
+      tool_use_id: "tool-123",
+      content: [{ type: "text", text: longText }],
+    };
+
+    const result = sanitizeToolResponsePayload("message.agent", payload);
+    expect(result.truncated).toBe(true);
+    expect(result.toolUseId).toBe("tool-123");
+
+    const sanitizedText = result.params.content[0].text as string;
+    expect(sanitizedText.endsWith(TOOL_RESPONSE_SUFFIX)).toBe(true);
+    expect(Buffer.byteLength(sanitizedText, "utf8")).toBeLessThanOrEqual(
+      TOOL_RESPONSE_BYTE_LIMIT + Buffer.byteLength(TOOL_RESPONSE_SUFFIX, "utf8")
+    );
+
+    // Ensure original payload was not mutated
+    expect(payload.content[0].text).toBe(longText);
+  });
+
+  it("enforces the byte budget across multiple string blocks", () => {
+    const firstBlockBytes = 400 * 1024;
+    const secondBlockBytes = 200 * 1024;
+    const payload = {
+      type: "tool_result",
+      content: [
+        { type: "text", text: "a".repeat(firstBlockBytes) },
+        { type: "text", text: "b".repeat(secondBlockBytes) },
+      ],
+    };
+
+    const result = sanitizeToolResponsePayload("message.agent", payload);
+    expect(result.truncated).toBe(true);
+
+    const first = result.params.content[0].text as string;
+    const second = result.params.content[1].text as string;
+
+    expect(Buffer.byteLength(first, "utf8")).toBe(firstBlockBytes);
+    expect(second.endsWith(TOOL_RESPONSE_SUFFIX)).toBe(true);
+    const combinedBytes =
+      Buffer.byteLength(first, "utf8") + Buffer.byteLength(second, "utf8");
+    expect(combinedBytes).toBeLessThanOrEqual(
+      TOOL_RESPONSE_BYTE_LIMIT + Buffer.byteLength(TOOL_RESPONSE_SUFFIX, "utf8")
+    );
+  });
+});