opencode-bifrost 0.0.1

package/src/tools/exec.ts

@@ -0,0 +1,68 @@
+import { homedir } from "os";
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { bifrostManager } from "../manager";
+import { validatePath, validateCommand } from "../security";
+
+export const bifrost_exec: ToolDefinition = tool({
+  description:
+    "Execute a command on the remote server via the persistent Bifrost SSH connection. Requires bifrost_connect to be called first (or auto-connects).",
+  args: {
+    command: tool.schema
+      .string()
+      .describe("The shell command to execute remotely"),
+    cwd: tool.schema
+      .string()
+      .optional()
+      .describe("Working directory on remote server"),
+    timeout: tool.schema
+      .number()
+      .int()
+      .default(30000)
+      .describe("Command timeout in milliseconds (default: 30000)"),
+  },
+  execute: async (args) => {
+    try {
+      // Auto-ensure connected with config
+      const configPath = `${homedir()}/.config/opencode/bifrost.json`;
+      if (!bifrostManager.config) {
+        bifrostManager.loadConfig(configPath);
+      }
+
+      await bifrostManager.ensureConnected();
+
+      const cmdValidation = validateCommand(args.command);
+      if (!cmdValidation.valid) {
+        return `Error: ${cmdValidation.error}`;
+      }
+
+      let builtCommand = args.command;
+      if (args.cwd) {
+        const cwdValidation = validatePath(args.cwd, "cwd");
+        if (!cwdValidation.valid) {
+          return `Error: ${cwdValidation.error}`;
+        }
+        // Escape single quotes in cwd for safe shell usage
+        const escapedCwd = args.cwd.replace(/'/g, "'\\''");
+        builtCommand = `cd '${escapedCwd}' && ${args.command}`;
+      }
+
+      const result = await bifrostManager.exec(builtCommand, { 
+        timeout: args.timeout,
+        maxOutputBytes: 10 * 1024 * 1024,
+      });
+
+      let output = `📡 Remote exec: ${args.command}\nExit code: ${result.exitCode}\n\nstdout:\n${result.stdout}`;
+      
+      if (result.stderr) {
+        output += `\n\nstderr:\n${result.stderr}`;
+      }
+
+      return output;
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return "Error: Unknown error occurred during remote execution";
+    }
+  },
+});

package/src/tools/status.ts

@@ -0,0 +1,49 @@
+import { homedir } from "os";
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { bifrostManager } from "../manager";
+import { existsSync } from "fs";
+
+export const bifrost_status: ToolDefinition = tool({
+  description:
+    "Check the status of the Bifrost SSH connection. Shows whether connected, server details, and connection health.",
+  args: {},
+  execute: async () => {
+    try {
+      const configPath = `${homedir()}/.config/opencode/bifrost.json`;
+
+      if (!existsSync(configPath)) {
+        return `🌈 Bifrost Status\nState: Disconnected\nError: No configuration found at ${configPath}`;
+      }
+
+      if (!bifrostManager.config) {
+        bifrostManager.loadConfig(configPath);
+      }
+
+      const connected = await bifrostManager.isConnected();
+      const config = bifrostManager.config;
+      const socketDir = bifrostManager.socketDir;
+
+      if (!config) {
+        return `🌈 Bifrost Status\nState: Disconnected\nError: Failed to load configuration`;
+      }
+
+      const socketPath = `${socketDir}/%C`;
+      const state = connected ? "Connected" : "Disconnected";
+      const server = `${config.user}@${config.host}:${config.port}`;
+      const socketStatus = connected ? "exists" : "missing";
+
+      let output = `🌈 Bifrost Status\nState: ${state}\nServer: ${server}\nSocket: ${socketPath} (${socketStatus})`;
+
+      if (connected) {
+        output += "\nHealth: Connection alive";
+      }
+
+      return output;
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return "Error: Unknown error occurred while checking status";
+    }
+  },
+});

package/src/tools/upload.ts

@@ -0,0 +1,56 @@
+import { existsSync, statSync } from "fs";
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { bifrostManager } from "../manager";
+import { validatePath } from "../security";
+
+export const bifrost_upload: ToolDefinition = tool({
+  description:
+    "Upload a local file to the remote server via the persistent Bifrost connection.",
+  args: {
+    localPath: tool.schema
+      .string()
+      .describe("Local file path to upload"),
+    remotePath: tool.schema
+      .string()
+      .describe("Remote file path destination"),
+  },
+  execute: async (args) => {
+    try {
+      const localValidation = validatePath(args.localPath, "localPath");
+      if (!localValidation.valid) {
+        return `Error: ${localValidation.error}`;
+      }
+
+      const remoteValidation = validatePath(args.remotePath, "remotePath");
+      if (!remoteValidation.valid) {
+        return `Error: ${remoteValidation.error}`;
+      }
+
+      if (!existsSync(args.localPath)) {
+        return `Error: Local file not found: ${args.localPath}`;
+      }
+
+      await bifrostManager.ensureConnected();
+
+      // Get file size before upload
+      const stat = statSync(args.localPath);
+      const fileSize = stat.size;
+
+      // Upload
+      await bifrostManager.upload(args.localPath, args.remotePath);
+
+      // Get config for display
+      const config = bifrostManager.config;
+      if (!config) {
+        return "Error: No config loaded";
+      }
+
+      return `📤 Uploaded ${args.localPath} → ${config.user}@${config.host}:${args.remotePath} (${fileSize} bytes)`;
+    } catch (error) {
+      if (error instanceof Error) {
+        return `Error: ${error.message}`;
+      }
+      return "Error: Unknown error occurred during upload";
+    }
+  },
+});

package/test/config.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { BifrostConfigSchema, parseConfig } from "../src/config";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, chmodSync } from "fs";
+import { tmpdir, homedir } from "os";
+import { join } from "path";
+
+describe("BifrostConfigSchema", () => {
+  describe("valid config parsing", () => {
+    it("parses config with all fields", () => {
+      const input = {
+        host: "192.168.1.100",
+        user: "admin",
+        keyPath: "/path/to/key",
+        port: 2222,
+        connectTimeout: 30,
+        controlPersist: "30m",
+        serverAliveInterval: 60,
+      };
+
+      const result = BifrostConfigSchema.parse(input);
+
+      expect(result.host).toBe("192.168.1.100");
+      expect(result.user).toBe("admin");
+      expect(result.keyPath).toBe("/path/to/key");
+      expect(result.port).toBe(2222);
+      expect(result.connectTimeout).toBe(30);
+      expect(result.controlPersist).toBe("30m");
+      expect(result.serverAliveInterval).toBe(60);
+    });
+
+    it("parses config with only required fields (defaults applied)", () => {
+      const input = {
+        host: "example.com",
+        keyPath: "/home/user/.ssh/id_rsa",
+      };
+
+      const result = BifrostConfigSchema.parse(input);
+
+      expect(result.host).toBe("example.com");
+      expect(result.keyPath).toBe("/home/user/.ssh/id_rsa");
+      expect(result.user).toBe("root");
+      expect(result.port).toBe(22);
+      expect(result.connectTimeout).toBe(10);
+      expect(result.controlPersist).toBe("15m");
+      expect(result.serverAliveInterval).toBe(30);
+    });
+  });
+
+  describe("invalid config validation", () => {
+    it("throws Zod error when host is missing", () => {
+      const input = {
+        keyPath: "/path/to/key",
+      };
+
+      expect(() => BifrostConfigSchema.parse(input)).toThrow();
+    });
+
+    it("throws Zod error when keyPath is missing", () => {
+      const input = {
+        host: "example.com",
+      };
+
+      expect(() => BifrostConfigSchema.parse(input)).toThrow();
+    });
+
+    it("throws Zod error for wrong types", () => {
+      const input = {
+        host: "example.com",
+        keyPath: "/path/to/key",
+        port: "not-a-number",
+      };
+
+      expect(() => BifrostConfigSchema.parse(input)).toThrow();
+    });
+
+    it("throws Zod error for negative port", () => {
+      const input = {
+        host: "example.com",
+        keyPath: "/path/to/key",
+        port: -1,
+      };
+
+      expect(() => BifrostConfigSchema.parse(input)).toThrow();
+    });
+
+    it("throws Zod error for non-integer port", () => {
+      const input = {
+        host: "example.com",
+        keyPath: "/path/to/key",
+        port: 22.5,
+      };
+
+      expect(() => BifrostConfigSchema.parse(input)).toThrow();
+    });
+  });
+});
+
+describe("parseConfig", () => {
+  let tempDir: string;
+  let keyPath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "bifrost-test-"));
+    keyPath = join(tempDir, "test_key");
+    writeFileSync(keyPath, "fake key content");
+    chmodSync(keyPath, 0o600);
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("parses valid config file with all fields", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      host: "192.168.1.100",
+      user: "admin",
+      keyPath: keyPath,
+      port: 2222,
+      connectTimeout: 30,
+      controlPersist: "30m",
+      serverAliveInterval: 60,
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    const result = parseConfig(configPath);
+
+    expect(result.host).toBe("192.168.1.100");
+    expect(result.user).toBe("admin");
+    expect(result.keyPath).toBe(keyPath);
+    expect(result.port).toBe(2222);
+    expect(result.connectTimeout).toBe(30);
+    expect(result.controlPersist).toBe("30m");
+    expect(result.serverAliveInterval).toBe(60);
+  });
+
+  it("parses valid config file with only required fields", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      host: "example.com",
+      keyPath: keyPath,
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    const result = parseConfig(configPath);
+
+    expect(result.host).toBe("example.com");
+    expect(result.keyPath).toBe(keyPath);
+    expect(result.user).toBe("root");
+    expect(result.port).toBe(22);
+    expect(result.connectTimeout).toBe(10);
+    expect(result.controlPersist).toBe("15m");
+    expect(result.serverAliveInterval).toBe(30);
+  });
+
+  it("throws error for missing host", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      keyPath: keyPath,
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    expect(() => parseConfig(configPath)).toThrow(/host/i);
+  });
+
+  it("throws error for missing keyPath", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      host: "example.com",
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    expect(() => parseConfig(configPath)).toThrow(/keyPath/i);
+  });
+
+  it("throws error for wrong types", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      host: "example.com",
+      keyPath: keyPath,
+      port: "not-a-number",
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    expect(() => parseConfig(configPath)).toThrow();
+  });
+
+  it("expands tilde in keyPath", () => {
+    const configPath = join(tempDir, "config.json");
+    const homeKeyPath = join(homedir(), ".ssh", "bifrost-test-key");
+    mkdirSync(join(homedir(), ".ssh"), { recursive: true });
+    writeFileSync(homeKeyPath, "fake key content");
+    chmodSync(homeKeyPath, 0o600);
+
+    try {
+      const config = {
+        host: "example.com",
+        keyPath: "~/.ssh/bifrost-test-key",
+      };
+      writeFileSync(configPath, JSON.stringify(config));
+
+      const result = parseConfig(configPath);
+
+      expect(result.keyPath).toBe(homeKeyPath);
+    } finally {
+      rmSync(homeKeyPath, { force: true });
+    }
+  });
+
+  it("throws error when config file does not exist", () => {
+    expect(() => parseConfig("/nonexistent/path/config.json")).toThrow(
+      /Config file not found/
+    );
+  });
+
+  it("throws error when key file does not exist", () => {
+    const configPath = join(tempDir, "config.json");
+    const config = {
+      host: "example.com",
+      keyPath: "/nonexistent/key",
+    };
+    writeFileSync(configPath, JSON.stringify(config));
+
+    expect(() => parseConfig(configPath)).toThrow(/Key file not found/);
+  });
+
+  it("throws error for invalid JSON", () => {
+    const configPath = join(tempDir, "config.json");
+    writeFileSync(configPath, "{ invalid json }");
+
+    expect(() => parseConfig(configPath)).toThrow(/JSON parse error/);
+  });
+});

package/test/integration.test.ts

@@ -0,0 +1,199 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+} from "bun:test";
+import { BifrostManager, BifrostError } from "../src/manager";
+import { mkdtempSync, writeFileSync, rmSync, existsSync, readFileSync } from "fs";
+import { tmpdir, homedir } from "os";
+import { join } from "path";
+
+const INTEGRATION_ENABLED = process.env.BIFROST_INTEGRATION === "true";
+const CONFIG_PATH = join(homedir(), ".config", "opencode", "bifrost.json");
+
+const describeIntegration = INTEGRATION_ENABLED ? describe : describe.skip;
+
+describeIntegration("Integration Tests", () => {
+  let manager: BifrostManager;
+  let tempDir: string;
+
+  beforeAll(() => {
+    if (!existsSync(CONFIG_PATH)) {
+      throw new Error(
+        `Integration tests require config at ${CONFIG_PATH}. Set BIFROST_INTEGRATION=true to run.`
+      );
+    }
+  });
+
+  beforeEach(() => {
+    manager = new BifrostManager();
+    manager.loadConfig(CONFIG_PATH);
+    tempDir = mkdtempSync(join(tmpdir(), "bifrost-integration-"));
+  });
+
+  afterEach(async () => {
+    try {
+      await manager.disconnect();
+    } catch {
+    }
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("full lifecycle", () => {
+    it("connect → exec → disconnect", async () => {
+      expect(manager.state).toBe("disconnected");
+
+      await manager.connect();
+      expect(manager.state).toBe("connected");
+
+      const result = await manager.exec("echo hello");
+      expect(result.stdout.trim()).toBe("hello");
+      expect(result.exitCode).toBe(0);
+
+      await manager.disconnect();
+      expect(manager.state).toBe("disconnected");
+    });
+
+    it("sequential command execution", async () => {
+      await manager.connect();
+
+      const result1 = await manager.exec("echo first");
+      expect(result1.stdout.trim()).toBe("first");
+
+      const result2 = await manager.exec("echo second");
+      expect(result2.stdout.trim()).toBe("second");
+
+      const result3 = await manager.exec("echo third");
+      expect(result3.stdout.trim()).toBe("third");
+
+      await manager.disconnect();
+    });
+  });
+
+  describe("auto-reconnect", () => {
+    it("reconnects after connection loss via ensureConnected", async () => {
+      await manager.connect();
+      expect(manager.state).toBe("connected");
+
+      await manager.disconnect();
+      expect(manager.state).toBe("disconnected");
+
+      await manager.ensureConnected();
+      expect(manager.state).toBe("connected");
+
+      const result = await manager.exec("echo reconnected");
+      expect(result.stdout.trim()).toBe("reconnected");
+    });
+  });
+
+  describe("file transfer", () => {
+    it("upload file", async () => {
+      await manager.connect();
+
+      const localFile = join(tempDir, "upload-test.txt");
+      const remotePath = `/tmp/bifrost-upload-test-${Date.now()}.txt`;
+      const testContent = `test content ${Date.now()}`;
+
+      writeFileSync(localFile, testContent);
+
+      await manager.upload(localFile, remotePath);
+
+      const result = await manager.exec(`cat ${remotePath} && rm ${remotePath}`);
+      expect(result.stdout.trim()).toBe(testContent);
+    });
+
+    it("download file", async () => {
+      await manager.connect();
+
+      const remotePath = `/tmp/bifrost-download-test-${Date.now()}.txt`;
+      const localFile = join(tempDir, "download-test.txt");
+      const testContent = `download content ${Date.now()}`;
+
+      await manager.exec(`echo '${testContent}' > ${remotePath}`);
+
+      await manager.download(remotePath, localFile);
+
+      expect(existsSync(localFile)).toBe(true);
+      const downloaded = readFileSync(localFile, "utf-8").trim();
+      expect(downloaded).toBe(testContent);
+
+      await manager.exec(`rm ${remotePath}`);
+    });
+  });
+
+  describe("status checks", () => {
+    it("isConnected returns true when connected", async () => {
+      await manager.connect();
+      const connected = await manager.isConnected();
+      expect(connected).toBe(true);
+    });
+
+    it("isConnected returns false when disconnected", async () => {
+      const connected = await manager.isConnected();
+      expect(connected).toBe(false);
+    });
+  });
+
+  describe("error handling", () => {
+    it("exec throws when not connected", async () => {
+      try {
+        await manager.exec("echo test");
+        expect(true).toBe(false);
+      } catch (err) {
+        expect(err).toBeInstanceOf(BifrostError);
+        expect((err as BifrostError).code).toBe("INVALID_STATE");
+      }
+    });
+  });
+});
+
+describeIntegration("Integration Tests - Error Cases", () => {
+  describe("unreachable host", () => {
+    it("throws UNREACHABLE error for invalid host", async () => {
+      const manager = new BifrostManager();
+      const tempDir = mkdtempSync(join(tmpdir(), "bifrost-unreachable-"));
+      const keyPath = join(tempDir, "fake_key");
+      const configPath = join(tempDir, "config.json");
+
+      writeFileSync(keyPath, "fake key");
+      const { chmodSync } = await import("fs");
+      chmodSync(keyPath, 0o600);
+
+      writeFileSync(
+        configPath,
+        JSON.stringify({
+          host: "192.0.2.1",
+          keyPath: keyPath,
+          connectTimeout: 3,
+        })
+      );
+
+      manager.loadConfig(configPath);
+
+      try {
+        await manager.connect();
+        expect(true).toBe(false);
+      } catch (err) {
+        expect(err).toBeInstanceOf(BifrostError);
+        const bifrostErr = err as BifrostError;
+        expect(["UNREACHABLE", "AUTH_FAILED"]).toContain(bifrostErr.code);
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+});
+
+describe("Integration Tests - Skip Check", () => {
+  it("skips when BIFROST_INTEGRATION is not set", () => {
+    if (!INTEGRATION_ENABLED) {
+      expect(true).toBe(true);
+    } else {
+      expect(INTEGRATION_ENABLED).toBe(true);
+    }
+  });
+});