@lobu/worker 6.0.1 → 7.0.0

package/src/__tests__/custom-tools.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createOpenClawCustomTools } from "../openclaw/custom-tools";
+
+const originalFetch = globalThis.fetch;
+
+describe("createOpenClawCustomTools", () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    mock.restore();
+  });
+
+  test("registers every built-in Lobu tool", () => {
+    const tools = createOpenClawCustomTools({
+      gatewayUrl: "http://gateway",
+      workerToken: "worker-token",
+      channelId: "channel-1",
+      conversationId: "conversation-1",
+      platform: "telegram",
+      workspaceDir: "/tmp/test-workspace",
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual([
+      "UploadUserFile",
+      "GenerateImage",
+      "GenerateAudio",
+      "GetChannelHistory",
+      "AskUserQuestion",
+    ]);
+  });
+
+  test("UploadUserFile emits a file-uploaded custom event after a successful upload", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "lobu-custom-tool-"));
+    const filePath = join(tempDir, "proof.txt");
+    writeFileSync(filePath, "proof");
+
+    const events: Array<{ name: string; data: Record<string, unknown> }> = [];
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (!url.endsWith("/internal/files/upload")) {
+        throw new Error(`Unexpected fetch: ${url}`);
+      }
+      return Response.json({
+        fileId: "file-123",
+        name: "proof.txt",
+        permalink: "https://files.example/proof.txt",
+      });
+    }) as unknown as typeof fetch;
+
+    try {
+      const uploadTool = createOpenClawCustomTools({
+        gatewayUrl: "http://gateway",
+        workerToken: "worker-token",
+        channelId: "channel-1",
+        conversationId: "conversation-1",
+        platform: "telegram",
+        workspaceDir: tempDir,
+        onCustomEvent: (name, data) => {
+          events.push({ name, data });
+        },
+      }).find((tool) => tool.name === "UploadUserFile");
+
+      expect(uploadTool).toBeDefined();
+
+      const result = await uploadTool!.execute("tool-call-1", {
+        file_path: filePath,
+      });
+
+      expect(result.content[0]?.text).toContain(
+        "Successfully showed proof.txt to the user"
+      );
+      expect(events).toEqual([
+        {
+          name: "file-uploaded",
+          data: {
+            tool: "UploadUserFile",
+            platform: "telegram",
+            fileId: "file-123",
+            name: "proof.txt",
+            permalink: "https://files.example/proof.txt",
+            size: 5,
+          },
+        },
+      ]);
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resetSandboxProbeForTests } from "../embedded/exec-sandbox";
+import {
+  buildBinaryInvocation,
+  createEmbeddedBashOps,
+} from "../embedded/just-bash-bootstrap";
+
+const tempDirs: string[] = [];
+const originalEnv = {
+  PATH: process.env.PATH,
+  LOBU_EXEC_SANDBOX: process.env.LOBU_EXEC_SANDBOX,
+  LOBU_ALLOW_UNSANDBOXED_EXEC: process.env.LOBU_ALLOW_UNSANDBOXED_EXEC,
+};
+
+function restoreEnv(name: keyof typeof originalEnv): void {
+  const value = originalEnv[name];
+  if (value === undefined) {
+    delete process.env[name];
+  } else {
+    process.env[name] = value;
+  }
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  restoreEnv("PATH");
+  restoreEnv("LOBU_EXEC_SANDBOX");
+  restoreEnv("LOBU_ALLOW_UNSANDBOXED_EXEC");
+  resetSandboxProbeForTests();
+});
+
+describe("createEmbeddedBashOps", () => {
+  test("does not register spawned PATH binaries without a sandbox or opt-in", async () => {
+    const workspace = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "lobu-sandbox-"))
+    );
+    tempDirs.push(workspace);
+
+    const nixBin = path.join(workspace, "nix", "store", "fake", "bin");
+    fs.mkdirSync(nixBin, { recursive: true });
+    const hostCat = path.join(nixBin, "hostcat");
+    fs.writeFileSync(hostCat, '#!/bin/sh\n/bin/cat "$@"\n', "utf8");
+    fs.chmodSync(hostCat, 0o755);
+
+    process.env.PATH = `${nixBin}:${process.env.PATH ?? ""}`;
+    process.env.LOBU_EXEC_SANDBOX = "off";
+    delete process.env.LOBU_ALLOW_UNSANDBOXED_EXEC;
+
+    const ops = await createEmbeddedBashOps({ workspaceDir: workspace });
+    const chunks: string[] = [];
+    const result = await ops.exec("hostcat /etc/passwd", "/", {
+      onData: (chunk) => chunks.push(chunk.toString()),
+      timeout: 5,
+    });
+
+    expect(result.exitCode).not.toBe(0);
+    expect(chunks.join("")).not.toContain("root:");
+  });
+});
+
+describe("buildBinaryInvocation", () => {
+  test("runs node shebang scripts through node", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "lobu-lobu-"));
+    tempDirs.push(dir);
+    const scriptPath = path.join(dir, "lobu");
+    fs.writeFileSync(
+      scriptPath,
+      "#!/usr/bin/env node\nconsole.log('ok');\n",
+      "utf8"
+    );
+    fs.chmodSync(scriptPath, 0o755);
+
+    expect(buildBinaryInvocation(scriptPath, ["version"])).toEqual({
+      command: "node",
+      args: [scriptPath, "version"],
+    });
+  });
+
+  test("executes normal binaries directly", () => {
+    expect(buildBinaryInvocation("/bin/echo", ["hello"])).toEqual({
+      command: "/bin/echo",
+      args: ["hello"],
+    });
+  });
+
+  test("wraps via sandbox when context provided", () => {
+    const ws = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "lobu-sandbox-"))
+    );
+    tempDirs.push(ws);
+    const r = buildBinaryInvocation("/bin/echo", ["hi"], {
+      strategy: { kind: "sandbox-exec", path: "/usr/bin/sandbox-exec" },
+      workspaceDir: ws,
+      allowNet: false,
+    });
+    expect(r.command).toBe("/usr/bin/sandbox-exec");
+    expect(r.args[0]).toBe("-p");
+    expect(r.args).toContain("/bin/echo");
+    expect(r.args).toContain("hi");
+  });
+
+  test("passes bwrap namespace cwd into the sandbox wrapper", () => {
+    const ws = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "lobu-sandbox-"))
+    );
+    tempDirs.push(ws);
+    const r = buildBinaryInvocation("/bin/echo", ["hi"], {
+      strategy: { kind: "bwrap", path: "/usr/bin/bwrap" },
+      workspaceDir: ws,
+      bwrapCwd: "/workspace/subdir",
+    });
+    const chdir = r.args.indexOf("--chdir");
+    expect(r.args[chdir + 1]).toBe("/workspace/subdir");
+  });
+
+  test("sandbox=none falls through to inner invocation", () => {
+    const r = buildBinaryInvocation("/bin/echo", ["hi"], {
+      strategy: { kind: "none" },
+      workspaceDir: "/tmp",
+    });
+    expect(r).toEqual({ command: "/bin/echo", args: ["hi"] });
+  });
+});

package/src/__tests__/embedded-mcp-cli-bash.test.ts

@@ -0,0 +1,179 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { McpToolDef } from "@lobu/core";
+import {
+  buildMcpCliCommands,
+  type McpCliDeps,
+  type McpRuntimeRef,
+} from "../embedded/mcp-cli-commands";
+import type { GatewayParams } from "../shared/tool-implementations";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+const gw: GatewayParams = {
+  gatewayUrl: "http://gateway",
+  workerToken: "worker-token",
+  channelId: "channel-1",
+  conversationId: "conversation-1",
+  platform: "telegram",
+};
+
+const searchKnowledge: McpToolDef = {
+  name: "search_memory",
+  description: "Search memory",
+  inputSchema: {
+    type: "object",
+    properties: { query: { type: "string" } },
+    required: ["query"],
+  },
+};
+
+async function buildBash(options: {
+  ref: McpRuntimeRef;
+  callTool: (
+    mcpId: string,
+    toolName: string,
+    payload: Record<string, unknown>
+  ) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+}) {
+  const { Bash, ReadWriteFs, defineCommand } = await import("just-bash");
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "lobu-mcp-cli-"));
+  tempDirs.push(tmp);
+
+  const callTool: McpCliDeps["callTool"] = async (
+    _gw,
+    mcpId,
+    toolName,
+    payload
+  ) => options.callTool(mcpId, toolName, payload);
+
+  const cliCommands = buildMcpCliCommands(options.ref, gw, { callTool });
+
+  const customCommands = cliCommands.map((c) =>
+    defineCommand(c.name, async (args: string[], ctx) => {
+      return c.execute(args, {
+        stdin: typeof ctx.stdin === "string" ? ctx.stdin : "",
+      });
+    })
+  );
+
+  const bash = new Bash({
+    fs: new ReadWriteFs({ root: tmp }),
+    cwd: "/",
+    env: { PATH: "/usr/bin:/bin" },
+    customCommands,
+  });
+
+  return bash;
+}
+
+describe("embedded MCP CLI through real just-bash", () => {
+  test("heredoc JSON on stdin reaches the handler as a parsed object", async () => {
+    const ref: McpRuntimeRef = {
+      current: {
+        mcpTools: { lobu: [searchKnowledge] },
+        mcpStatus: [],
+        mcpContext: {},
+      },
+    };
+    const calls: Array<{ payload: Record<string, unknown> }> = [];
+    const bash = await buildBash({
+      ref,
+      callTool: async (_mcpId, _toolName, payload) => {
+        calls.push({ payload });
+        return { content: [{ type: "text", text: "hit" }] };
+      },
+    });
+
+    const result = await bash.exec(
+      `lobu search_memory <<'EOF'
+{"query":"architecture"}
+EOF`,
+      { cwd: "/" }
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.trim()).toBe("hit");
+    expect(calls).toEqual([{ payload: { query: "architecture" } }]);
+  });
+
+  test("echo … | <server> <tool> routes the piped JSON into the handler", async () => {
+    const ref: McpRuntimeRef = {
+      current: {
+        mcpTools: { lobu: [searchKnowledge] },
+        mcpStatus: [],
+        mcpContext: {},
+      },
+    };
+    const calls: Array<{ payload: Record<string, unknown> }> = [];
+    const bash = await buildBash({
+      ref,
+      callTool: async (_mcpId, _toolName, payload) => {
+        calls.push({ payload });
+        return { content: [{ type: "text", text: "ok" }] };
+      },
+    });
+
+    const result = await bash.exec(
+      `echo '{"query":"piped"}' | lobu search_memory`,
+      { cwd: "/" }
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(calls).toEqual([{ payload: { query: "piped" } }]);
+  });
+
+  test("<server> --help lists the discovered tools", async () => {
+    const ref: McpRuntimeRef = {
+      current: {
+        mcpTools: { lobu: [searchKnowledge] },
+        mcpStatus: [
+          {
+            id: "lobu",
+            name: "Lobu",
+            requiresAuth: true,
+            requiresInput: false,
+            authenticated: true,
+            configured: true,
+          },
+        ],
+        mcpContext: {},
+      },
+    };
+    const bash = await buildBash({
+      ref,
+      callTool: async () => ({ content: [] }),
+    });
+
+    const result = await bash.exec("lobu --help", { cwd: "/" });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("search_memory");
+    expect(result.stdout).toContain("auth login|check|logout");
+  });
+
+  test("unknown subcommand exits with stderr diagnostic", async () => {
+    const ref: McpRuntimeRef = {
+      current: {
+        mcpTools: { lobu: [] },
+        mcpStatus: [],
+        mcpContext: {},
+      },
+    };
+    const bash = await buildBash({
+      ref,
+      callTool: async () => ({ content: [] }),
+    });
+
+    const result = await bash.exec("lobu mystery", { cwd: "/" });
+    expect(result.exitCode).toBe(2);
+    expect(result.stderr).toContain("unknown tool");
+  });
+});