@lobu/worker 3.0.9 → 3.0.12

package/src/core/workspace.ts

@@ -1,138 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import {
-  createLogger,
-  sanitizeConversationId,
-  WorkspaceError,
-} from "@lobu/core";
-import type { WorkspaceInfo, WorkspaceSetupConfig } from "./types";
-
-const logger = createLogger("workspace");
-
-// ============================================================================
-// WORKSPACE UTILITIES
-// ============================================================================
-
-/**
- * Get workspace directory path for a thread
- */
-function getWorkspacePathForThread(
-  baseDirectory: string,
-  conversationId: string
-): string {
-  // Sanitize thread ID for filesystem
-  const sanitizedConversationId = sanitizeConversationId(conversationId);
-  return `${baseDirectory}/${sanitizedConversationId}`;
-}
-
-/**
- * Setup workspace directory environment variable
- * Used by MCP process manager
- */
-export function setupWorkspaceEnv(deploymentName: string | undefined): void {
-  const conversationId = process.env.CONVERSATION_ID;
-
-  if (conversationId) {
-    const baseDir = process.env.WORKSPACE_DIR || "/workspace";
-    const workspaceDir = getWorkspacePathForThread(baseDir, conversationId);
-    process.env.WORKSPACE_DIR = workspaceDir;
-    logger.info(`📁 Set WORKSPACE_DIR for process manager: ${workspaceDir}`);
-  } else if (deploymentName) {
-    // deploymentName is no longer parseable (it may be hashed/collision-resistant).
-    logger.warn("WORKSPACE_DIR not set (missing CONVERSATION_ID env var)");
-  }
-}
-
-/**
- * Get conversation identifier from various sources
- * Priority: CONVERSATION_ID > sessionKey > username
- */
-function getThreadIdentifier(sessionKey?: string, username?: string): string {
-  const conversationId =
-    process.env.CONVERSATION_ID || sessionKey || username || "default";
-
-  return conversationId;
-}
-
-// ============================================================================
-// WORKSPACE MANAGER
-// ============================================================================
-
-/**
- * Simplified WorkspaceManager - only handles directory creation
- * All VCS operations (git, etc.) are handled by modules via hooks
- */
-export class WorkspaceManager {
-  private config: WorkspaceSetupConfig;
-  private workspaceInfo?: WorkspaceInfo;
-
-  constructor(config: WorkspaceSetupConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Setup workspace directory - creates thread-specific directory only
-   * VCS operations are handled by module hooks (e.g., GitHub module)
-   */
-  async setupWorkspace(
-    username: string,
-    sessionKey?: string
-  ): Promise<WorkspaceInfo> {
-    try {
-      // Use thread-specific directory to avoid conflicts between concurrent threads
-      const conversationId = getThreadIdentifier(sessionKey, username);
-
-      logger.info(
-        `Setting up workspace directory for ${username}, conversation: ${conversationId}...`
-      );
-
-      const userDirectory = getWorkspacePathForThread(
-        this.config.baseDirectory,
-        conversationId
-      );
-
-      // Ensure base directory exists
-      await this.ensureDirectory(this.config.baseDirectory);
-
-      // Ensure user directory exists
-      await this.ensureDirectory(userDirectory);
-
-      // Create workspace info
-      this.workspaceInfo = {
-        baseDirectory: this.config.baseDirectory,
-        userDirectory,
-      };
-
-      logger.info(
-        `Workspace directory setup completed for ${username} (conversation: ${conversationId}) at ${userDirectory}`
-      );
-
-      return this.workspaceInfo;
-    } catch (error) {
-      throw new WorkspaceError(
-        "setupWorkspace",
-        `Failed to setup workspace directory`,
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Ensure directory exists
-   */
-  private async ensureDirectory(path: string): Promise<void> {
-    try {
-      await mkdir(path, { recursive: true });
-    } catch (error: any) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * Get current working directory
-   */
-  getCurrentWorkingDirectory(): string {
-    return this.workspaceInfo?.userDirectory || this.config.baseDirectory;
-  }
-}

package/src/embedded/just-bash-bootstrap.ts

@@ -1,228 +0,0 @@
-/**
- * Worker-side just-bash bootstrap for embedded deployment mode.
- *
- * Creates a just-bash Bash instance from environment variables and wraps it
- * as a BashOperations interface for pi-coding-agent's bash tool.
- *
- * When nix binaries are detected on PATH (via nix-shell wrapper from gateway)
- * or known CLI tools (e.g. owletto) are found, they are registered as
- * just-bash customCommands that delegate to real exec.
- */
-
-import { execFile } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import type { BashOperations } from "@mariozechner/pi-coding-agent";
-
-const EMBEDDED_BASH_LIMITS = {
-  maxCommandCount: 50_000,
-  maxLoopIterations: 50_000,
-  maxCallDepth: 50,
-} as const;
-
-export function buildBinaryInvocation(
-  binaryPath: string,
-  args: string[]
-): { command: string; args: string[] } {
-  try {
-    const firstLine =
-      fs.readFileSync(binaryPath, "utf8").split("\n", 1)[0] || "";
-    if (firstLine === "#!/usr/bin/env node" || firstLine.endsWith("/node")) {
-      return { command: "node", args: [binaryPath, ...args] };
-    }
-  } catch {
-    // Fall back to executing the binary directly.
-  }
-
-  return { command: binaryPath, args };
-}
-
-/**
- * Discover binaries to register as custom commands:
- * 1. All executables from /nix/store/ PATH directories
- * 2. Known CLI tools (owletto) from anywhere on PATH
- */
-function discoverBinaries(): Map<string, string> {
-  const binaries = new Map<string, string>();
-  const pathDirs = (process.env.PATH || "").split(":");
-
-  for (const dir of pathDirs) {
-    if (!dir.includes("/nix/store/")) continue;
-    try {
-      for (const entry of fs.readdirSync(dir)) {
-        const fullPath = path.join(dir, entry);
-        try {
-          fs.accessSync(fullPath, fs.constants.X_OK);
-          if (!binaries.has(entry)) binaries.set(entry, fullPath);
-        } catch {
-          // not executable
-        }
-      }
-    } catch {
-      // directory not readable
-    }
-  }
-
-  // Discover known CLI tools from full PATH
-  for (const name of ["owletto"]) {
-    if (binaries.has(name)) continue;
-    for (const dir of pathDirs) {
-      const fullPath = path.join(dir, name);
-      try {
-        fs.accessSync(fullPath, fs.constants.X_OK);
-        binaries.set(name, fullPath);
-        break;
-      } catch {
-        // not found
-      }
-    }
-  }
-
-  return binaries;
-}
-
-/**
- * Create just-bash customCommands from a map of binary name → full path.
- * Each custom command delegates to the real binary via child_process.execFile.
- */
-async function buildCustomCommands(
-  binaries: Map<string, string>
-): Promise<ReturnType<typeof import("just-bash").defineCommand>[]> {
-  const { defineCommand } = await import("just-bash");
-  const commands = [];
-
-  for (const [name, binaryPath] of binaries) {
-    commands.push(
-      defineCommand(name, async (args: string[], ctx) => {
-        const invocation = buildBinaryInvocation(binaryPath, args);
-
-        // Convert ctx.env (Map-like) to a plain Record for child_process
-        const envRecord: Record<string, string> = { ...process.env } as Record<
-          string,
-          string
-        >;
-        if (ctx.env && typeof ctx.env.forEach === "function") {
-          ctx.env.forEach((v: string, k: string) => {
-            envRecord[k] = v;
-          });
-        } else if (ctx.env && typeof ctx.env === "object") {
-          Object.assign(envRecord, ctx.env);
-        }
-
-        return new Promise<{
-          stdout: string;
-          stderr: string;
-          exitCode: number;
-        }>((resolve) => {
-          execFile(
-            invocation.command,
-            invocation.args,
-            {
-              cwd: ctx.cwd,
-              env: envRecord,
-              maxBuffer: 10 * 1024 * 1024,
-            },
-            (error, stdout, stderr) => {
-              resolve({
-                stdout: stdout || "",
-                stderr: stderr || (error?.message ?? ""),
-                exitCode: error?.code ? Number(error.code) || 1 : 0,
-              });
-            }
-          );
-        });
-      })
-    );
-  }
-
-  return commands;
-}
-
-/**
- * Create a BashOperations adapter backed by a just-bash Bash instance.
- * Reads configuration from environment variables.
- */
-export async function createEmbeddedBashOps(): Promise<BashOperations> {
-  const { Bash, ReadWriteFs } = await import("just-bash");
-
-  const workspaceDir = process.env.WORKSPACE_DIR || "/workspace";
-  const bashFs = new ReadWriteFs({ root: workspaceDir });
-
-  // Parse allowed domains from env var (set by gateway)
-  let allowedDomains: string[] = [];
-  if (process.env.JUST_BASH_ALLOWED_DOMAINS) {
-    try {
-      allowedDomains = JSON.parse(process.env.JUST_BASH_ALLOWED_DOMAINS);
-    } catch {
-      console.error(
-        `[embedded] Failed to parse JUST_BASH_ALLOWED_DOMAINS: ${process.env.JUST_BASH_ALLOWED_DOMAINS}`
-      );
-    }
-  }
-
-  const network =
-    allowedDomains.length > 0
-      ? {
-          allowedUrlPrefixes: allowedDomains.flatMap((domain: string) => [
-            `https://${domain}/`,
-            `http://${domain}/`,
-          ]),
-          allowedMethods: ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"] as (
-            | "GET"
-            | "HEAD"
-            | "POST"
-            | "PUT"
-            | "PATCH"
-            | "DELETE"
-          )[],
-        }
-      : undefined;
-
-  // Discover nix binaries and known CLI tools, register as custom commands
-  const binaries = discoverBinaries();
-  const customCommands =
-    binaries.size > 0 ? await buildCustomCommands(binaries) : [];
-
-  if (binaries.size > 0) {
-    const names = [...binaries.keys()].slice(0, 20).join(", ");
-    const suffix = binaries.size > 20 ? `, ... (${binaries.size} total)` : "";
-    console.log(
-      `[embedded] Registered ${binaries.size} custom commands: ${names}${suffix}`
-    );
-  }
-
-  const bashInstance = new Bash({
-    fs: bashFs,
-    cwd: "/",
-    env: Object.fromEntries(
-      Object.entries(process.env).filter(
-        (entry): entry is [string, string] => entry[1] !== undefined
-      )
-    ),
-    executionLimits: EMBEDDED_BASH_LIMITS,
-    ...(network && { network }),
-    ...(customCommands.length > 0 && { customCommands }),
-  });
-
-  return {
-    async exec(command, cwd, { onData, signal, timeout }) {
-      const timeoutMs =
-        timeout !== undefined && timeout > 0 ? timeout * 1000 : undefined;
-
-      const result = await bashInstance.exec(command, {
-        cwd,
-        signal,
-        env: { TIMEOUT_MS: timeoutMs ? String(timeoutMs) : "" },
-      });
-
-      if (result.stdout) {
-        onData(Buffer.from(result.stdout));
-      }
-      if (result.stderr) {
-        onData(Buffer.from(result.stderr));
-      }
-
-      return { exitCode: result.exitCode };
-    },
-  };
-}

package/src/gateway/gateway-integration.ts

@@ -1,287 +0,0 @@
-/**
- * HTTP implementation of WorkerTransport
- * Sends worker responses to gateway via HTTP POST requests
- */
-
-import {
-  createLogger,
-  retryWithBackoff,
-  type WorkerTransport,
-  type WorkerTransportConfig,
-} from "@lobu/core";
-import type { ResponseData } from "./types";
-
-const logger = createLogger("http-worker-transport");
-
-/**
- * HTTP transport for worker-to-gateway communication
- * Implements retry logic and deduplication for streaming responses
- */
-export class HttpWorkerTransport implements WorkerTransport {
-  private gatewayUrl: string;
-  private workerToken: string;
-  private userId: string;
-  private channelId: string;
-  private conversationId: string;
-  private originalMessageTs: string;
-  private botResponseTs?: string;
-  public processedMessageIds: string[] = [];
-  private jobId?: string;
-  private moduleData?: Record<string, unknown>;
-  private teamId: string;
-  private platform?: string;
-  private platformMetadata?: Record<string, unknown>;
-  private accumulatedStreamContent: string[] = [];
-  private lastStreamDelta: string = "";
-
-  constructor(config: WorkerTransportConfig) {
-    this.gatewayUrl = config.gatewayUrl;
-    this.workerToken = config.workerToken;
-    this.userId = config.userId;
-    this.channelId = config.channelId;
-    this.conversationId = config.conversationId;
-    this.originalMessageTs = config.originalMessageTs;
-    this.botResponseTs = config.botResponseTs;
-    this.teamId = config.teamId;
-    this.platform = config.platform;
-    this.platformMetadata = config.platformMetadata;
-    this.processedMessageIds = config.processedMessageIds || [];
-  }
-
-  setJobId(jobId: string): void {
-    this.jobId = jobId;
-  }
-
-  setModuleData(moduleData: Record<string, unknown>): void {
-    this.moduleData = moduleData;
-  }
-
-  async signalDone(finalDelta?: string): Promise<void> {
-    // Send final delta if there is one
-    if (finalDelta) {
-      await this.sendStreamDelta(finalDelta, false, true);
-    }
-    await this.signalCompletion();
-  }
-
-  async sendStreamDelta(
-    delta: string,
-    isFullReplacement: boolean = false,
-    isFinal: boolean = false
-  ): Promise<void> {
-    let actualDelta = delta;
-
-    // Handle final result with deduplication
-    if (isFinal) {
-      logger.info(`🔍 Processing final result with deduplication`);
-      logger.info(`Final text length: ${delta.length} chars`);
-      const accumulatedStr = this.accumulatedStreamContent.join("");
-      const accumulatedLength = accumulatedStr.length;
-      logger.info(`Accumulated length: ${accumulatedLength} chars`);
-
-      // Check if final result is identical to what we've already sent
-      if (delta === accumulatedStr) {
-        logger.info(
-          `✅ Final result is identical to accumulated content - skipping duplicate`
-        );
-        return;
-      }
-
-      // Check if accumulated content is a prefix of final result
-      if (delta.startsWith(accumulatedStr)) {
-        // Only send the missing part
-        actualDelta = delta.slice(accumulatedLength);
-        if (actualDelta.length === 0) {
-          logger.info(
-            `✅ Final result fully contained in accumulated content - skipping`
-          );
-          return;
-        }
-        logger.info(
-          `📝 Final result has ${actualDelta.length} new chars - sending delta only`
-        );
-      } else if (accumulatedLength > 0) {
-        const normalizedFinal = this.normalizeForComparison(delta);
-        const normalizedLastDelta = this.normalizeForComparison(
-          this.lastStreamDelta
-        );
-
-        if (
-          normalizedFinal.length > 0 &&
-          normalizedFinal === normalizedLastDelta
-        ) {
-          logger.info(
-            `✅ Final result matches last streamed delta (normalized) - skipping duplicate`
-          );
-          return;
-        }
-
-        // Content differs - log warning and send full final result
-        logger.warn(`⚠️  Final result differs from accumulated content!`);
-        logger.warn(
-          `First 100 chars of accumulated: ${accumulatedStr.substring(0, 100)}`
-        );
-        logger.warn(`First 100 chars of final: ${delta.substring(0, 100)}`);
-        logger.info(`📤 Sending full final result (${delta.length} chars)`);
-      }
-    }
-
-    // Track accumulated content for deduplication using array buffer (O(1) append)
-    if (!isFullReplacement) {
-      this.accumulatedStreamContent.push(actualDelta);
-    } else {
-      this.accumulatedStreamContent = [actualDelta];
-    }
-    this.lastStreamDelta = actualDelta;
-
-    await this.sendResponse(
-      this.buildBaseResponse({
-        delta: actualDelta,
-        moduleData: this.moduleData,
-        isFullReplacement,
-      })
-    );
-  }
-
-  async signalCompletion(): Promise<void> {
-    await this.sendResponse(
-      this.buildBaseResponse({
-        processedMessageIds: this.processedMessageIds,
-        moduleData: this.moduleData,
-      })
-    );
-  }
-
-  async signalError(error: Error, errorCode?: string): Promise<void> {
-    await this.sendResponse(
-      this.buildBaseResponse({
-        error: error.message,
-        ...(errorCode && { errorCode }),
-      })
-    );
-  }
-
-  async sendStatusUpdate(elapsedSeconds: number, state: string): Promise<void> {
-    await this.sendResponse(
-      this.buildBaseResponse({
-        statusUpdate: { elapsedSeconds, state },
-      })
-    );
-  }
-
-  /**
-   * Build base response payload with common fields shared across all response types
-   */
-  private buildBaseResponse(
-    additionalFields?: Partial<ResponseData>
-  ): ResponseData {
-    return {
-      messageId: this.originalMessageTs,
-      channelId: this.channelId,
-      conversationId: this.conversationId,
-      userId: this.userId,
-      teamId: this.teamId,
-      timestamp: Date.now(),
-      originalMessageId: this.originalMessageTs,
-      botResponseId: this.botResponseTs,
-      ...additionalFields,
-    };
-  }
-
-  /**
-   * Build exec response payload with exec-specific fields
-   */
-  private buildExecResponse(
-    execId: string,
-    additionalFields: Partial<ResponseData>
-  ): ResponseData {
-    return this.buildBaseResponse({ execId, ...additionalFields });
-  }
-
-  /**
-   * Send exec output (stdout/stderr) to gateway
-   */
-  async sendExecOutput(
-    execId: string,
-    stream: "stdout" | "stderr",
-    content: string
-  ): Promise<void> {
-    await this.sendResponse(
-      this.buildExecResponse(execId, { delta: content, execStream: stream })
-    );
-  }
-
-  /**
-   * Send exec completion to gateway
-   */
-  async sendExecComplete(execId: string, exitCode: number): Promise<void> {
-    await this.sendResponse(
-      this.buildExecResponse(execId, { execExitCode: exitCode })
-    );
-  }
-
-  /**
-   * Send exec error to gateway
-   */
-  async sendExecError(execId: string, errorMessage: string): Promise<void> {
-    await this.sendResponse(
-      this.buildExecResponse(execId, { error: errorMessage })
-    );
-  }
-
-  private async sendResponse(data: ResponseData): Promise<void> {
-    const responseUrl = `${this.gatewayUrl}/worker/response`;
-    const basePayload = {
-      ...data,
-      ...(this.platform && !data.platform ? { platform: this.platform } : {}),
-      ...(!data.platformMetadata && this.platformMetadata
-        ? { platformMetadata: this.platformMetadata }
-        : {}),
-    };
-    const payload = this.jobId
-      ? { jobId: this.jobId, ...basePayload }
-      : basePayload;
-
-    await retryWithBackoff(
-      async () => {
-        logger.info(
-          `[WORKER-HTTP] Sending to ${responseUrl}: ${JSON.stringify(payload).substring(0, 500)}`
-        );
-        if (payload.delta) {
-          logger.info(
-            `[WORKER-HTTP] Stream delta payload: deltaLength=${payload.delta?.length}`
-          );
-        }
-
-        const response = await fetch(responseUrl, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.workerToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify(payload),
-          signal: AbortSignal.timeout(30_000),
-        });
-
-        if (!response.ok) {
-          throw new Error(
-            `Failed to send response to dispatcher: ${response.status} ${response.statusText}`
-          );
-        }
-
-        logger.debug("Response sent to dispatcher successfully");
-      },
-      {
-        maxRetries: 2,
-        baseDelay: 1000,
-        onRetry: (attempt, error) => {
-          logger.warn(`Failed to send response (attempt ${attempt}/2):`, error);
-        },
-      }
-    );
-  }
-
-  private normalizeForComparison(text: string): string {
-    return text.replace(/\r\n/g, "\n").trim();
-  }
-}