@dobby.ai/dobby 0.1.1 → 0.1.2

package/plugins/sandbox-core/src/docker-contribution.ts

@@ -1,43 +0,0 @@
-import { resolve } from "node:path";
-import { z } from "zod";
-import type { SandboxContributionModule } from "@dobby.ai/plugin-sdk";
-import { DockerExecutor } from "./docker-executor.js";
-
-const dockerSandboxConfigSchema = z.object({
-  container: z.string().min(1),
-  hostWorkspaceRoot: z.string().min(1),
-  containerWorkspaceRoot: z.string().min(1).default("/workspace"),
-});
-
-function resolveMaybeAbsolute(baseDir: string, value: string): string {
-  if (value === "~") {
-    return resolve(process.env.HOME ?? "", ".");
-  }
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return resolve(process.env.HOME ?? "", value.slice(2));
-  }
-  return resolve(baseDir, value);
-}
-
-export const sandboxDockerContribution: SandboxContributionModule = {
-  kind: "sandbox",
-  configSchema: z.toJSONSchema(dockerSandboxConfigSchema),
-  async createInstance(options) {
-    const parsed = dockerSandboxConfigSchema.parse(options.config);
-    const executor = await DockerExecutor.create(
-      {
-        container: parsed.container,
-        hostWorkspaceRoot: resolveMaybeAbsolute(options.host.configBaseDir, parsed.hostWorkspaceRoot),
-        containerWorkspaceRoot: parsed.containerWorkspaceRoot,
-      },
-      options.host.logger,
-    );
-
-    return {
-      id: options.instanceId,
-      executor,
-    };
-  },
-};
-
-export default sandboxDockerContribution;

package/plugins/sandbox-core/src/docker-executor.ts

@@ -1,217 +0,0 @@
-import { spawn } from "node:child_process";
-import { resolve, sep } from "node:path";
-import type { GatewayLogger } from "@dobby.ai/plugin-sdk";
-import type { ExecOptions, ExecResult, Executor, SpawnOptions, SpawnedProcess } from "@dobby.ai/plugin-sdk";
-
-export interface DockerConfig {
-  container: string;
-  hostWorkspaceRoot: string;
-  containerWorkspaceRoot: string;
-}
-
-function shellEscape(value: string): string {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-
-function normalizePrefix(path: string): string {
-  return path.endsWith(sep) ? path : `${path}${sep}`;
-}
-
-export class DockerExecutor implements Executor {
-  private readonly normalizedHostRoot: string;
-
-  private constructor(
-    private readonly config: DockerConfig,
-    private readonly logger: GatewayLogger,
-  ) {
-    this.normalizedHostRoot = normalizePrefix(resolve(config.hostWorkspaceRoot));
-  }
-
-  static async create(config: DockerConfig, logger: GatewayLogger): Promise<DockerExecutor> {
-    const instance = new DockerExecutor(config, logger);
-    await instance.validate();
-    return instance;
-  }
-
-  async exec(command: string, cwd: string, options: ExecOptions = {}): Promise<ExecResult> {
-    const containerCwd = this.toContainerPath(cwd);
-    const wrapped = `cd ${shellEscape(containerCwd)} && ${command}`;
-
-    const args = ["exec", "-i"];
-    if (options.env) {
-      for (const [key, value] of Object.entries(options.env)) {
-        if (value !== undefined) {
-          args.push("-e", `${key}=${value}`);
-        }
-      }
-    }
-    args.push(this.config.container, "sh", "-lc", wrapped);
-
-    return new Promise<ExecResult>((resolveResult, reject) => {
-      const child = spawn("docker", args, {
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-
-      let stdout = "";
-      let stderr = "";
-      let killed = false;
-
-      const onAbort = () => {
-        killed = true;
-        child.kill("SIGKILL");
-      };
-
-      let timeoutHandle: NodeJS.Timeout | undefined;
-      if (options.timeoutSeconds && options.timeoutSeconds > 0) {
-        timeoutHandle = setTimeout(onAbort, options.timeoutSeconds * 1000);
-      }
-
-      if (options.signal) {
-        if (options.signal.aborted) {
-          onAbort();
-        } else {
-          options.signal.addEventListener("abort", onAbort, { once: true });
-        }
-      }
-
-      child.stdout.on("data", (chunk) => {
-        stdout += String(chunk);
-      });
-      child.stderr.on("data", (chunk) => {
-        stderr += String(chunk);
-      });
-
-      child.on("error", (error) => {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        if (options.signal) options.signal.removeEventListener("abort", onAbort);
-        reject(error);
-      });
-
-      child.on("close", (code) => {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        if (options.signal) options.signal.removeEventListener("abort", onAbort);
-        resolveResult({ stdout, stderr, code: code ?? 0, killed });
-      });
-    });
-  }
-
-  spawn(options: SpawnOptions): SpawnedProcess {
-    const cwd = options.cwd ?? this.config.hostWorkspaceRoot;
-    const containerCwd = this.toContainerPath(cwd);
-    const argv = [options.command, ...options.args].map(shellEscape).join(" ");
-    const wrapped = `cd ${shellEscape(containerCwd)} && exec ${argv}`;
-
-    const args = ["exec", "-i"];
-    if (options.tty) {
-      args.push("-t");
-    }
-    if (options.env) {
-      for (const [key, value] of Object.entries(options.env)) {
-        if (value !== undefined) {
-          args.push("-e", `${key}=${value}`);
-        }
-      }
-    }
-    args.push(this.config.container, "sh", "-lc", wrapped);
-
-    const child = spawn("docker", args, {
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    const onAbort = () => {
-      child.kill("SIGKILL");
-    };
-
-    if (options.signal) {
-      if (options.signal.aborted) {
-        onAbort();
-      } else {
-        options.signal.addEventListener("abort", onAbort, { once: true });
-        child.once("exit", () => {
-          options.signal?.removeEventListener("abort", onAbort);
-        });
-      }
-    }
-
-    if (!child.stdin || !child.stdout || !child.stderr) {
-      child.kill("SIGKILL");
-      throw new Error("Docker executor failed to create stdio pipes for spawned process");
-    }
-
-    const spawned: SpawnedProcess = {
-      stdin: child.stdin,
-      stdout: child.stdout,
-      stderr: child.stderr,
-      get killed() {
-        return child.killed;
-      },
-      get exitCode() {
-        return child.exitCode;
-      },
-      kill(signal = "SIGKILL") {
-        return child.kill(signal);
-      },
-      on(event, listener) {
-        child.on(event, listener as (...args: unknown[]) => void);
-      },
-      once(event, listener) {
-        child.once(event, listener as (...args: unknown[]) => void);
-      },
-      off(event, listener) {
-        child.off(event, listener as (...args: unknown[]) => void);
-      },
-    };
-
-    return spawned;
-  }
-
-  async close(): Promise<void> {
-    this.logger.debug({ container: this.config.container }, "DockerExecutor closed");
-  }
-
-  private async validate(): Promise<void> {
-    await this.execSimple("docker", ["--version"]);
-
-    const inspect = await this.execSimple("docker", ["inspect", "-f", "{{.State.Running}}", this.config.container]);
-    if (inspect.trim() !== "true") {
-      throw new Error(`Docker container '${this.config.container}' is not running`);
-    }
-  }
-
-  private toContainerPath(hostPath: string): string {
-    const resolved = resolve(hostPath);
-    if (!resolved.startsWith(this.normalizedHostRoot) && resolved !== this.normalizedHostRoot.slice(0, -1)) {
-      throw new Error(`Path '${resolved}' is outside docker hostWorkspaceRoot '${this.config.hostWorkspaceRoot}'`);
-    }
-
-    const relative = resolved.slice(this.normalizedHostRoot.length).replaceAll("\\", "/");
-    const base = this.config.containerWorkspaceRoot.endsWith("/")
-      ? this.config.containerWorkspaceRoot.slice(0, -1)
-      : this.config.containerWorkspaceRoot;
-
-    return relative.length > 0 ? `${base}/${relative}` : base;
-  }
-
-  private execSimple(command: string, args: string[]): Promise<string> {
-    return new Promise((resolveOutput, reject) => {
-      const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-      let stdout = "";
-      let stderr = "";
-
-      child.stdout.on("data", (chunk) => {
-        stdout += String(chunk);
-      });
-      child.stderr.on("data", (chunk) => {
-        stderr += String(chunk);
-      });
-      child.on("error", reject);
-      child.on("close", (code) => {
-        if (code === 0) {
-          resolveOutput(stdout);
-        } else {
-          reject(new Error(stderr || `Command failed: ${command} ${args.join(" ")}`));
-        }
-      });
-    });
-  }
-}

package/plugins/sandbox-core/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["node"],
-    "strict": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["dist", "node_modules"]
-}

package/scripts/local-extensions.mjs

@@ -1,168 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "node:child_process";
-import { access, readdir, readFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const scriptDir = dirname(fileURLToPath(import.meta.url));
-const projectRoot = resolve(scriptDir, "..");
-
-const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
-const nodeCommand = process.execPath;
-
-const pluginsRootDir = resolve(projectRoot, "plugins");
-const pluginSdkDir = "plugins/plugin-sdk";
-
-async function discoverLocalExtensionPackages() {
-  const entries = await readdir(pluginsRootDir, { withFileTypes: true });
-  const discovered = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    if (entry.name === "plugin-sdk") {
-      continue;
-    }
-
-    const relativeDir = `plugins/${entry.name}`;
-    const packageJsonPath = resolve(projectRoot, relativeDir, "package.json");
-    const manifestPath = resolve(projectRoot, relativeDir, "dobby.manifest.json");
-
-    try {
-      await access(packageJsonPath);
-      await access(manifestPath);
-      const rawPackageJson = await readFile(packageJsonPath, "utf-8");
-      const parsedPackageJson = JSON.parse(rawPackageJson);
-      if (typeof parsedPackageJson?.name !== "string" || parsedPackageJson.name.length === 0) {
-        throw new Error(`Missing package name in ${packageJsonPath}`);
-      }
-
-      discovered.push({
-        name: parsedPackageJson.name,
-        dir: relativeDir,
-      });
-    } catch {
-      continue;
-    }
-  }
-
-  discovered.sort((a, b) => a.dir.localeCompare(b.dir));
-  return discovered;
-}
-
-function printUsage() {
-  console.log("Usage: node scripts/local-extensions.mjs <command>");
-  console.log("");
-  console.log("Commands:");
-  console.log("  install       Install local plugin development dependencies");
-  console.log("  check         Type-check local extension plugins");
-  console.log("  build         Build local extension plugins");
-  console.log("  install-store Install local extension plugins into extension store");
-  console.log("  list-store    List installed extensions from extension store");
-  console.log("  setup         Run install + build + install-store");
-}
-
-async function run(command, args) {
-  const pretty = [command, ...args].join(" ");
-  console.log(`$ ${pretty}`);
-
-  await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command, args, {
-      cwd: projectRoot,
-      stdio: "inherit",
-      env: process.env,
-    });
-
-    child.once("error", (error) => rejectPromise(error));
-    child.once("exit", (code) => {
-      if (code === 0) {
-        resolvePromise();
-        return;
-      }
-      rejectPromise(new Error(`Command failed (${code ?? "unknown"}): ${pretty}`));
-    });
-  });
-}
-
-async function installLocalPluginDeps(localExtensionPackages) {
-  await run(npmCommand, ["install", "--prefix", pluginSdkDir]);
-  for (const item of localExtensionPackages) {
-    await run(npmCommand, ["install", "--prefix", item.dir]);
-  }
-}
-
-async function checkLocalPlugins(localExtensionPackages) {
-  for (const item of localExtensionPackages) {
-    await run(npmCommand, ["run", "check", "--prefix", item.dir]);
-  }
-}
-
-async function buildLocalPlugins(localExtensionPackages) {
-  for (const item of localExtensionPackages) {
-    await run(npmCommand, ["run", "build", "--prefix", item.dir]);
-  }
-}
-
-async function installToExtensionStore(localExtensionPackages) {
-  for (const item of localExtensionPackages) {
-    await run(nodeCommand, [
-      "--import",
-      "tsx",
-      "src/main.ts",
-      "extension",
-      "install",
-      `file:./${item.dir}`,
-    ]);
-  }
-}
-
-async function listExtensionStore() {
-  await run(nodeCommand, ["--import", "tsx", "src/main.ts", "extension", "list"]);
-}
-
-async function main() {
-  const [command] = process.argv.slice(2);
-
-  if (!command || command === "--help" || command === "-h") {
-    printUsage();
-    process.exit(command ? 0 : 1);
-  }
-
-  const needsLocalPackages = command !== "list-store";
-  const localExtensionPackages = needsLocalPackages ? await discoverLocalExtensionPackages() : [];
-  if (needsLocalPackages && localExtensionPackages.length === 0) {
-    throw new Error("No local extension packages found under ./plugins");
-  }
-
-  switch (command) {
-    case "install":
-      await installLocalPluginDeps(localExtensionPackages);
-      return;
-    case "check":
-      await checkLocalPlugins(localExtensionPackages);
-      return;
-    case "build":
-      await buildLocalPlugins(localExtensionPackages);
-      return;
-    case "install-store":
-      await installToExtensionStore(localExtensionPackages);
-      return;
-    case "list-store":
-      await listExtensionStore();
-      return;
-    case "setup":
-      await installLocalPluginDeps(localExtensionPackages);
-      await buildLocalPlugins(localExtensionPackages);
-      await installToExtensionStore(localExtensionPackages);
-      return;
-    default:
-      throw new Error(`Unknown command '${command}'`);
-  }
-}
-
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});