@dobby.ai/dobby 0.1.1 → 0.1.2

package/plugins/provider-pi/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "@dobby.ai/provider-pi",
-  "version": "0.1.3",
-  "private": false,
-  "type": "module",
-  "description": "Built-in pi provider extension package",
-  "main": "./index.js",
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "check": "tsc -p tsconfig.json --noEmit",
-    "prepack": "npm run build"
-  },
-  "dependencies": {
-    "@mariozechner/pi-agent-core": "^0.53.0",
-    "@mariozechner/pi-ai": "^0.53.0",
-    "@mariozechner/pi-coding-agent": "^0.53.0",
-    "zod": "^4.3.6"
-  },
-  "peerDependencies": {
-    "@dobby.ai/plugin-sdk": "^0.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@dobby.ai/plugin-sdk": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@dobby.ai/plugin-sdk": "file:../plugin-sdk",
-    "@types/node": "^22.10.5",
-    "typescript": "^5.9.2"
-  },
-  "files": [
-    "index.js",
-    "dist/",
-    "dobby.manifest.json"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}

package/plugins/provider-pi/src/contribution.ts

@@ -1,606 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import type { AgentMessage, ThinkingLevel } from "@mariozechner/pi-agent-core";
-import {
-  AuthStorage,
-  type CreateAgentSessionOptions,
-  type ToolDefinition,
-  createAgentSession,
-  createBashTool,
-  createEditTool,
-  createFindTool,
-  createGrepTool,
-  createLsTool,
-  createReadTool,
-  createWriteTool,
-  ModelRegistry,
-  SessionManager,
-  type AgentSession,
-  type BashOperations,
-  type EditOperations,
-  type ReadOperations,
-  type WriteOperations,
-} from "@mariozechner/pi-coding-agent";
-import type { Api, ImageContent, Model } from "@mariozechner/pi-ai";
-import { z } from "zod";
-import type {
-  GatewayAgentEvent,
-  GatewayAgentRuntime,
-  ProviderContributionModule,
-  ProviderInstance,
-  ProviderInstanceCreateOptions,
-  ProviderSessionArchiveOptions,
-  ProviderRuntimeCreateOptions,
-} from "@dobby.ai/plugin-sdk";
-
-const BOXLITE_CONTEXT_CONVERSATION_KEY_ENV = "__IM_AGENT_BOXLITE_CONVERSATION_KEY";
-const BOXLITE_CONTEXT_PROJECT_ROOT_ENV = "__IM_AGENT_BOXLITE_PROJECT_ROOT";
-
-type RuntimeTool = NonNullable<CreateAgentSessionOptions["tools"]>[number];
-
-interface PiProviderConfig {
-  provider: string;
-  model: string;
-  baseUrl: string;
-  apiKey: string;
-  api: Api;
-  headers?: Record<string, string>;
-  authHeader: boolean;
-  models: PiProviderModelConfig[];
-  thinkingLevel: ThinkingLevel;
-  agentDir?: string;
-  authFile?: string;
-}
-
-interface PiProviderModelConfig {
-  id: string;
-  name: string;
-  api?: Api;
-  reasoning: boolean;
-  input: Array<"text" | "image">;
-  cost: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-  };
-  contextWindow: number;
-  maxTokens: number;
-  headers?: Record<string, string>;
-}
-
-interface BuiltTools {
-  activeTools: RuntimeTool[];
-  customTools: ToolDefinition[];
-}
-
-const DEFAULT_PI_PROVIDER_NAME = "custom-openai";
-const DEFAULT_PI_PROVIDER_API = "openai-completions";
-const DEFAULT_PI_MODEL_COST = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-} as const;
-
-const PI_PROVIDER_APIS = [
-  "anthropic-messages",
-  "openai-completions",
-  "mistral-conversations",
-  "openai-responses",
-  "azure-openai-responses",
-  "openai-codex-responses",
-  "google-generative-ai",
-  "google-gemini-cli",
-  "google-vertex",
-  "bedrock-converse-stream",
-] as const;
-
-const piProviderApiSchema = z.enum(PI_PROVIDER_APIS);
-
-const piProviderModelSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1).optional(),
-  api: piProviderApiSchema.optional(),
-  reasoning: z.boolean().default(false),
-  input: z.array(z.enum(["text", "image"])).min(1).default(["text"]),
-  cost: z.object({
-    input: z.number().default(0),
-    output: z.number().default(0),
-    cacheRead: z.number().default(0),
-    cacheWrite: z.number().default(0),
-  }).default(DEFAULT_PI_MODEL_COST),
-  contextWindow: z.number().int().positive().default(128000),
-  maxTokens: z.number().int().positive().default(16384),
-  headers: z.record(z.string(), z.string()).optional(),
-});
-
-const piProviderConfigSchema = z.object({
-  provider: z.string().min(1).optional(),
-  model: z.string().min(1),
-  baseUrl: z.string().min(1),
-  apiKey: z.string().min(1),
-  api: piProviderApiSchema.optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  authHeader: z.boolean().optional(),
-  models: z.array(piProviderModelSchema).min(1).optional(),
-  thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
-  agentDir: z.string().optional(),
-  authFile: z.string().optional(),
-});
-
-function buildImplicitModelConfig(modelId: string): PiProviderModelConfig {
-  return {
-    id: modelId,
-    name: modelId,
-    reasoning: false,
-    input: ["text"],
-    cost: { ...DEFAULT_PI_MODEL_COST },
-    contextWindow: 128000,
-    maxTokens: 16384,
-  };
-}
-
-function normalizePiProviderModels(
-  activeModelId: string,
-  models: Array<z.infer<typeof piProviderModelSchema>> | undefined,
-): PiProviderModelConfig[] {
-  if (!models || models.length === 0) {
-    return [buildImplicitModelConfig(activeModelId)];
-  }
-
-  const normalizedModels = models.map((model) => ({
-    id: model.id,
-    name: model.name ?? model.id,
-    ...(model.api ? { api: model.api } : {}),
-    reasoning: model.reasoning,
-    input: model.input,
-    cost: model.cost,
-    contextWindow: model.contextWindow,
-    maxTokens: model.maxTokens,
-    ...(model.headers ? { headers: model.headers } : {}),
-  }));
-
-  if (!normalizedModels.some((model) => model.id === activeModelId)) {
-    throw new Error(`Configured model '${activeModelId}' is not present in provider.pi models`);
-  }
-
-  return normalizedModels;
-}
-
-const IMAGE_MIME_TYPES: Record<string, string> = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-};
-
-function assertWithinRoot(absolutePath: string, rootDir: string): void {
-  const normalizedRoot = resolve(rootDir);
-  const normalizedPath = resolve(absolutePath);
-  const rootPrefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
-
-  if (normalizedPath !== normalizedRoot && !normalizedPath.startsWith(rootPrefix)) {
-    throw new Error(`Path '${normalizedPath}' is outside allowed project root '${normalizedRoot}'`);
-  }
-}
-
-function safeSegment(value: string): string {
-  return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
-}
-
-function extractAssistantText(message: AgentMessage): string {
-  if (message.role !== "assistant") return "";
-  const blocks = message.content.filter((block): block is { type: "text"; text: string } => block.type === "text");
-  return blocks.map((block) => block.text).join("\n");
-}
-
-function extractToolResultText(result: unknown): string {
-  if (!result || typeof result !== "object") return "(no output)";
-  const content = (result as { content?: unknown }).content;
-  if (!Array.isArray(content)) return "(no output)";
-
-  const textBlocks = content.filter(
-    (block): block is { type: "text"; text: string } =>
-      typeof block === "object" &&
-      block !== null &&
-      "type" in block &&
-      (block as { type: string }).type === "text" &&
-      "text" in block,
-  );
-
-  const text = textBlocks.map((block) => block.text).join("\n").trim();
-  return text.length > 0 ? text : "(no output)";
-}
-
-function normalizeMaybePath(configBaseDir: string, value: string | undefined): string | undefined {
-  if (!value) return undefined;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return undefined;
-  if (trimmed === "~") return resolve(process.env.HOME ?? "", ".");
-  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return resolve(process.env.HOME ?? "", trimmed.slice(2));
-  }
-  return resolve(configBaseDir, trimmed);
-}
-
-function formatArchiveStamp(timestampMs: number): string {
-  return new Date(timestampMs).toISOString().replaceAll(":", "-").replaceAll(".", "-");
-}
-
-async function archiveSessionPath(
-  sessionsDir: string,
-  sourcePath: string,
-  archivedAtMs: number,
-): Promise<string | undefined> {
-  const relativePath = relative(sessionsDir, sourcePath);
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    throw new Error(`Session path '${sourcePath}' is outside sessions dir '${sessionsDir}'`);
-  }
-
-  const archiveRoot = join(sessionsDir, "_archived", `${formatArchiveStamp(archivedAtMs)}-${randomUUID().slice(0, 8)}`);
-  const archivePath = join(archiveRoot, relativePath);
-  await mkdir(dirname(archivePath), { recursive: true });
-
-  try {
-    await rename(sourcePath, archivePath);
-    return archivePath;
-  } catch (error) {
-    const asErr = error as NodeJS.ErrnoException;
-    if (asErr.code === "ENOENT") {
-      return undefined;
-    }
-    throw error;
-  }
-}
-
-class PiGatewayRuntime implements GatewayAgentRuntime {
-  constructor(private readonly session: AgentSession) {}
-
-  async prompt(text: string, options?: { images?: ImageContent[] }): Promise<void> {
-    if (options?.images && options.images.length > 0) {
-      await this.session.prompt(text, { images: options.images });
-      return;
-    }
-    await this.session.prompt(text);
-  }
-
-  subscribe(listener: (event: GatewayAgentEvent) => void): () => void {
-    return this.session.subscribe((event) => {
-      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-        listener({ type: "message_delta", delta: event.assistantMessageEvent.delta });
-        return;
-      }
-
-      if (event.type === "message_end" && event.message.role === "assistant") {
-        const finalText = extractAssistantText(event.message);
-        if (finalText.trim().length > 0) {
-          listener({ type: "message_complete", text: finalText });
-        }
-        return;
-      }
-
-      if (event.type === "tool_execution_start") {
-        listener({ type: "tool_start", toolName: event.toolName });
-        return;
-      }
-
-      if (event.type === "tool_execution_end") {
-        listener({
-          type: "tool_end",
-          toolName: event.toolName,
-          isError: event.isError,
-          output: extractToolResultText(event.result),
-        });
-        return;
-      }
-
-      if (event.type === "auto_compaction_start") {
-        listener({ type: "status", message: `Compacting context (${event.reason})...` });
-        return;
-      }
-
-      if (event.type === "auto_retry_start") {
-        listener({ type: "status", message: `Retrying (${event.attempt}/${event.maxAttempts})...` });
-      }
-    });
-  }
-
-  async abort(): Promise<void> {
-    await this.session.abort();
-  }
-
-  dispose(): void {
-    this.session.dispose();
-  }
-}
-
-class PiProviderInstanceImpl implements ProviderInstance {
-  private readonly authStorage: AuthStorage;
-  private readonly modelRegistry: ModelRegistry;
-  private readonly model: Model<Api>;
-
-  constructor(
-    readonly id: string,
-    private readonly providerConfig: PiProviderConfig,
-    private readonly dataConfig: ProviderInstanceCreateOptions["data"],
-    private readonly logger: ProviderInstanceCreateOptions["host"]["logger"],
-  ) {
-    this.authStorage = AuthStorage.create(providerConfig.authFile);
-    // Point the registry at a never-created file so provider.pi relies solely on inline config.
-    this.modelRegistry = new ModelRegistry(this.authStorage, join(dataConfig.stateDir, "__dobby_provider_pi_inline_models__", `${safeSegment(id)}.json`));
-    this.modelRegistry.registerProvider(providerConfig.provider, {
-      baseUrl: providerConfig.baseUrl,
-      apiKey: providerConfig.apiKey,
-      api: providerConfig.api,
-      ...(providerConfig.headers ? { headers: providerConfig.headers } : {}),
-      ...(providerConfig.authHeader ? { authHeader: true } : {}),
-      models: providerConfig.models.map((model) => ({
-        id: model.id,
-        name: model.name,
-        ...(model.api ? { api: model.api } : {}),
-        reasoning: model.reasoning,
-        input: model.input,
-        cost: model.cost,
-        contextWindow: model.contextWindow,
-        maxTokens: model.maxTokens,
-        ...(model.headers ? { headers: model.headers } : {}),
-      })),
-    });
-
-    const model = this.modelRegistry.find(providerConfig.provider, providerConfig.model);
-    if (!model) {
-      throw new Error(`Configured model '${providerConfig.provider}/${providerConfig.model}' not found`);
-    }
-    this.model = model;
-  }
-
-  async createRuntime(options: ProviderRuntimeCreateOptions): Promise<GatewayAgentRuntime> {
-    const sessionFile = options.sessionPolicy === "ephemeral"
-      ? this.getEphemeralSessionFilePath(options.conversationKey)
-      : this.getSessionFilePath(options.inbound);
-    const sessionDir = dirname(sessionFile);
-
-    await mkdir(this.dataConfig.sessionsDir, { recursive: true });
-    await mkdir(this.dataConfig.logsDir, { recursive: true });
-    await mkdir(this.dataConfig.stateDir, { recursive: true });
-    await mkdir(this.dataConfig.attachmentsDir, { recursive: true });
-    await mkdir(sessionDir, { recursive: true });
-
-    const builtTools = this.buildTools(
-      options.conversationKey,
-      options.route.profile.projectRoot,
-      options.route.profile.tools,
-      options,
-    );
-
-    const sessionOptions = {
-      cwd: options.route.profile.projectRoot,
-      authStorage: this.authStorage,
-      modelRegistry: this.modelRegistry,
-      sessionManager: SessionManager.open(sessionFile, sessionDir),
-      model: this.model,
-      thinkingLevel: this.providerConfig.thinkingLevel,
-      tools: builtTools.activeTools,
-      customTools: builtTools.customTools,
-      ...(this.providerConfig.agentDir ? { agentDir: this.providerConfig.agentDir } : {}),
-    };
-
-    const { session } = await createAgentSession(sessionOptions);
-
-    this.logger.info(
-      {
-        providerInstance: this.id,
-        activeTools: builtTools.activeTools.map((tool) => tool.name),
-      },
-      "Provider runtime initialized",
-    );
-
-    if (options.route.profile.systemPromptFile) {
-      try {
-        const prompt = await readFile(options.route.profile.systemPromptFile, "utf-8");
-        session.agent.setSystemPrompt(prompt);
-      } catch (error) {
-        this.logger.warn(
-          { err: error, routeId: options.route.routeId, file: options.route.profile.systemPromptFile },
-          "Failed to load route system prompt; continuing with default",
-        );
-      }
-    }
-
-    return new PiGatewayRuntime(session);
-  }
-
-  async archiveSession(options: ProviderSessionArchiveOptions): Promise<{ archived: boolean; archivePath?: string }> {
-    const sessionFile = options.sessionPolicy === "ephemeral"
-      ? this.getEphemeralSessionFilePath(options.conversationKey)
-      : this.getSessionFilePath(options.inbound);
-    const archivePath = await archiveSessionPath(
-      this.dataConfig.sessionsDir,
-      sessionFile,
-      options.archivedAtMs ?? Date.now(),
-    );
-    return archivePath ? { archived: true, archivePath } : { archived: false };
-  }
-
-  private buildTools(
-    conversationKey: string,
-    projectRoot: string,
-    profile: "full" | "readonly",
-    options: ProviderRuntimeCreateOptions,
-  ): BuiltTools {
-    const readOps: ReadOperations = {
-      access: async (absolutePath) => {
-        assertWithinRoot(absolutePath, projectRoot);
-      },
-      readFile: async (absolutePath) => {
-        assertWithinRoot(absolutePath, projectRoot);
-        return readFile(absolutePath);
-      },
-      detectImageMimeType: async (absolutePath) => {
-        const ext = extname(absolutePath).toLowerCase();
-        return IMAGE_MIME_TYPES[ext] ?? null;
-      },
-    };
-
-    const writeOps: WriteOperations = {
-      mkdir: async (dir) => {
-        assertWithinRoot(dir, projectRoot);
-        await mkdir(dir, { recursive: true });
-      },
-      writeFile: async (absolutePath, content) => {
-        assertWithinRoot(absolutePath, projectRoot);
-        await writeFile(absolutePath, content, "utf-8");
-      },
-    };
-
-    const editOps: EditOperations = {
-      access: async (absolutePath) => {
-        assertWithinRoot(absolutePath, projectRoot);
-      },
-      readFile: async (absolutePath) => {
-        assertWithinRoot(absolutePath, projectRoot);
-        return readFile(absolutePath);
-      },
-      writeFile: async (absolutePath, content) => {
-        assertWithinRoot(absolutePath, projectRoot);
-        await writeFile(absolutePath, content, "utf-8");
-      },
-    };
-
-    const bashOps: BashOperations = {
-      exec: async (command, cwd, execOptionsFromTool) => {
-        const env: NodeJS.ProcessEnv = {
-          ...(execOptionsFromTool.env ?? {}),
-          [BOXLITE_CONTEXT_CONVERSATION_KEY_ENV]: conversationKey,
-          [BOXLITE_CONTEXT_PROJECT_ROOT_ENV]: projectRoot,
-        };
-
-        const execOptions = {
-          ...(execOptionsFromTool.signal ? { signal: execOptionsFromTool.signal } : {}),
-          ...(execOptionsFromTool.timeout !== undefined ? { timeoutSeconds: execOptionsFromTool.timeout } : {}),
-          env,
-        };
-
-        this.logger.info(
-          {
-            providerInstance: this.id,
-            sandboxExecutorType: options.executor.constructor?.name ?? "unknown",
-            cwd,
-            timeoutSeconds: execOptions.timeoutSeconds,
-          },
-          "Dispatching bash command to sandbox executor",
-        );
-
-        const result = await options.executor.exec(command, cwd, execOptions);
-        const combined = `${result.stdout}${result.stderr}`;
-        if (combined.length > 0) {
-          execOptionsFromTool.onData(Buffer.from(combined, "utf-8"));
-        }
-
-        this.logger.info(
-          {
-            providerInstance: this.id,
-            sandboxExecutorType: options.executor.constructor?.name ?? "unknown",
-            code: result.code,
-            killed: result.killed,
-            stdoutBytes: Buffer.byteLength(result.stdout, "utf-8"),
-            stderrBytes: Buffer.byteLength(result.stderr, "utf-8"),
-          },
-          "Sandbox executor completed bash command",
-        );
-
-        return { exitCode: result.killed ? null : result.code };
-      },
-    };
-
-    const readTool = createReadTool(projectRoot, { operations: readOps }) as RuntimeTool;
-    const bashTool = createBashTool(projectRoot, { operations: bashOps }) as RuntimeTool;
-    const editTool = createEditTool(projectRoot, { operations: editOps }) as RuntimeTool;
-    const writeTool = createWriteTool(projectRoot, { operations: writeOps }) as RuntimeTool;
-    const grepTool = createGrepTool(projectRoot) as RuntimeTool;
-    const findTool = createFindTool(projectRoot) as RuntimeTool;
-    const lsTool = createLsTool(projectRoot) as RuntimeTool;
-
-    if (profile === "readonly") {
-      const activeTools = [readTool, grepTool, findTool, lsTool];
-      return {
-        activeTools,
-        customTools: activeTools.map((tool) => this.toCustomToolDefinition(tool)),
-      };
-    }
-
-    const activeTools = [readTool, bashTool, editTool, writeTool];
-    return {
-      activeTools,
-      customTools: activeTools.map((tool) => this.toCustomToolDefinition(tool)),
-    };
-  }
-
-  private toCustomToolDefinition(tool: RuntimeTool): ToolDefinition {
-    return {
-      name: tool.name,
-      label: tool.label,
-      description: tool.description,
-      parameters: tool.parameters,
-      execute: (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
-    };
-  }
-
-  private getSessionFilePath(inbound: ProviderRuntimeCreateOptions["inbound"]): string {
-    const guildSegment = safeSegment(inbound.guildId ?? "dm");
-    const connectorSegment = safeSegment(inbound.connectorId);
-    const sourceSegment = safeSegment(inbound.source.id);
-    const threadSegment = safeSegment(inbound.threadId ?? "root");
-    const chatSegment = safeSegment(inbound.chatId);
-
-    return join(
-      this.dataConfig.sessionsDir,
-      connectorSegment,
-      inbound.platform,
-      safeSegment(inbound.accountId),
-      guildSegment,
-      sourceSegment,
-      threadSegment,
-      `${chatSegment}.jsonl`,
-    );
-  }
-
-  private getEphemeralSessionFilePath(conversationKey: string): string {
-    return join(
-      this.dataConfig.sessionsDir,
-      "_cron-ephemeral",
-      `${safeSegment(conversationKey)}.jsonl`,
-    );
-  }
-}
-
-export const providerPiContribution: ProviderContributionModule = {
-  kind: "provider",
-  configSchema: z.toJSONSchema(piProviderConfigSchema),
-  createInstance(options) {
-    const parsed = piProviderConfigSchema.parse(options.config);
-    const agentDir = normalizeMaybePath(options.host.configBaseDir, parsed.agentDir);
-    const authFile = normalizeMaybePath(options.host.configBaseDir, parsed.authFile);
-
-    const normalizedConfig: PiProviderConfig = {
-      provider: parsed.provider ?? DEFAULT_PI_PROVIDER_NAME,
-      model: parsed.model,
-      baseUrl: parsed.baseUrl,
-      apiKey: parsed.apiKey,
-      api: parsed.api ?? DEFAULT_PI_PROVIDER_API,
-      ...(parsed.headers ? { headers: parsed.headers } : {}),
-      authHeader: parsed.authHeader ?? false,
-      models: normalizePiProviderModels(parsed.model, parsed.models),
-      thinkingLevel: parsed.thinkingLevel ?? "off",
-      ...(agentDir ? { agentDir } : {}),
-      ...(authFile ? { authFile } : {}),
-    };
-
-    return new PiProviderInstanceImpl(options.instanceId, normalizedConfig, options.data, options.host.logger);
-  },
-};
-
-export default providerPiContribution;

package/plugins/provider-pi/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/plugins/sandbox-core/boxlite.js

@@ -1 +0,0 @@
-export { sandboxBoxliteContribution as contribution, sandboxBoxliteContribution as default } from "./dist/boxlite-contribution.js";

package/plugins/sandbox-core/dobby.manifest.json

@@ -1,17 +0,0 @@
-{
-  "apiVersion": "1.0",
-  "name": "@dobby.ai/sandbox-core",
-  "version": "0.1.0",
-  "contributions": [
-    {
-      "id": "sandbox.docker",
-      "kind": "sandbox",
-      "entry": "./dist/docker-contribution.js"
-    },
-    {
-      "id": "sandbox.boxlite",
-      "kind": "sandbox",
-      "entry": "./dist/boxlite-contribution.js"
-    }
-  ]
-}

package/plugins/sandbox-core/docker.js

@@ -1 +0,0 @@
-export { sandboxDockerContribution as contribution, sandboxDockerContribution as default } from "./dist/docker-contribution.js";