@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-btm2ep20.js

@@ -0,0 +1,113 @@
+import {
+  useragent2
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  ID18,
+  isAISDK2
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  iife2
+} from "./aisdk-native-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./aisdk-native-6g46d628.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID18.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin2 = define({
+  id: "opencode.provider.cloudflare.workers.ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {}))
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "accountId",
+          title: "Enter your Cloudflare Account ID",
+          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          form
+        }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      evt.provider.update(item.provider.id, (provider) => {
+        if (!isAISDK2(provider.package))
+          return;
+        if (typeof provider.settings?.baseURL === "string")
+          return;
+        const accountId = resolveAccountId(provider.settings ?? {});
+        if (accountId)
+          provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) };
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      if (evt.package !== "@ai-sdk/openai-compatible")
+        return;
+      const accountId = resolveAccountId(evt.options);
+      if (!hasWorkersEndpoint(evt.model) && !accountId)
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(sdkOptions({
+        ...evt.options,
+        baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined)
+      }, ctx.app));
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+function resolveAccountId(options) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+}
+function workersEndpoint(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`;
+}
+function hasWorkersEndpoint(model) {
+  return isAISDK2(model.package) && typeof model.settings?.baseURL === "string";
+}
+function sdkOptions(options, app) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${useragent2(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers
+    },
+    name: providerID
+  };
+}
+function expandAccountId(baseURL) {
+  if (typeof baseURL !== "string")
+    return baseURL;
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}");
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareWorkersAIPlugin2 };

package/dist/chunks/aisdk-native-bxz5a0az.js

@@ -0,0 +1,214 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  ID9,
+  Service62,
+  node66
+} from "./aisdk-native-x0v86zgp.js";
+import {
+  AgentNotFoundError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  combine2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  provenance2
+} from "./aisdk-native-msq0jde0.js";
+import {
+  entriesForRunner2
+} from "./aisdk-native-pvvztgda.js";
+import {
+  Service61,
+  node65
+} from "./aisdk-native-smbad60v.js";
+import {
+  merge2
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service65,
+  node69
+} from "./aisdk-native-r4kwqy5f.js";
+import {
+  make14
+} from "./aisdk-native-rn79xn25.js";
+import {
+  Service48,
+  node51
+} from "./aisdk-native-45smdebh.js";
+import {
+  Service22,
+  node27
+} from "./aisdk-native-82j2mrwz.js";
+import {
+  Service34,
+  node38
+} from "./aisdk-native-g27wjat6.js";
+import {
+  Service30,
+  node34
+} from "./aisdk-native-hzekcpqj.js";
+import {
+  Service28,
+  node32
+} from "./aisdk-native-xpf9b544.js";
+import {
+  Service29,
+  node33
+} from "./aisdk-native-gbt8yvwm.js";
+import {
+  Service23,
+  node28
+} from "./aisdk-native-ge3a0kr9.js";
+import {
+  Service24,
+  node29
+} from "./aisdk-native-3175eqdp.js";
+import {
+  Service25,
+  node30
+} from "./aisdk-native-k996mbzp.js";
+import {
+  Service41,
+  node44
+} from "./aisdk-native-tmmjahvp.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/context.ts
+var exports_context = {};
+__export(exports_context, {
+  Service: () => Service21,
+  SessionContext: () => exports_context,
+  node: () => node26
+});
+import { Model } from "@opencode/schema/model";
+import { Context, Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class Service21 extends Context.Service()("@opencode/SessionContext") {
+}
+var layer = Layer.effect(Service21, Effect.gen(function* () {
+  const agents = yield* Service62;
+  const builtins = yield* Service22;
+  const catalog = yield* Service65;
+  const db = (yield* Service80).db;
+  const discovery = yield* Service48;
+  const entries = yield* Service24;
+  const location = yield* Service73;
+  const mcpInstructions = yield* Service28;
+  const mcpTools = yield* Service30;
+  const models = yield* Service41;
+  const request = yield* Service25;
+  const referenceInstructions = yield* Service29;
+  const skillInstructions = yield* Service23;
+  const store = yield* Service61;
+  const registry = yield* Service34;
+  const resolveModel = (session) => models.resolve(session, catalog.model.available);
+  const selectTitle = Effect.fn("SessionContext.selectTitle")(function* (session) {
+    const agent = yield* agents.get(ID9.make("title"));
+    if (!agent)
+      return;
+    const primary = yield* resolveModel(session).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    const info = yield* Effect.gen(function* () {
+      if (agent.model)
+        return yield* catalog.model.get(agent.model.providerID, agent.model.id);
+      if (!primary)
+        return;
+      return yield* catalog.model.small(primary.ref.providerID);
+    });
+    const variant = agent.model?.variant ?? MINIMAL_REASONING_VARIANTS.find((id) => info?.variants.some((item) => item.id === id));
+    const preferred = info && (yield* resolveModel({
+      ...session,
+      model: Model.Ref.make({
+        providerID: info.providerID,
+        id: info.id,
+        ...variant ? { variant } : {}
+      })
+    }).pipe(Effect.orElseSucceed(() => {
+      return;
+    })));
+    const selected = preferred ?? primary;
+    if (!selected)
+      return;
+    return { agent, primary, selected };
+  });
+  const select = Effect.fn("SessionContext.select")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
+      return yield* Effect.interrupt;
+    yield* mcpTools.flush;
+    const agent = yield* agents.select(session.agent);
+    if (!agent.info)
+      return yield* new AgentNotFoundError2({ sessionID: session.id, agent: session.agent ?? agent.id });
+    const loaded = yield* Effect.all({
+      tools: registry.snapshot(merge2(agent.info.permissions, session.permissions ?? [])),
+      builtins: builtins.load(sessionID),
+      discovery: discovery.load(),
+      skills: skillInstructions.load(agent),
+      references: referenceInstructions.load(),
+      mcp: mcpInstructions.load(agent),
+      entries: entries.load(sessionID)
+    }, { concurrency: "unbounded" });
+    return {
+      session,
+      agent: { ...agent, info: agent.info },
+      instructions: combine2([
+        loaded.builtins,
+        make14(loaded.tools.codeModeCatalog),
+        loaded.discovery,
+        loaded.skills,
+        loaded.references,
+        loaded.mcp,
+        loaded.entries
+      ]),
+      tools: loaded.tools
+    };
+  });
+  const load = Effect.fn("SessionContext.load")(function* (selection) {
+    const model = yield* resolveModel(selection.session);
+    const history = yield* entriesForRunner2(db, selection.session.id, selection.instructions, provenance2(model) ?? "local");
+    return {
+      session: selection.session,
+      agent: selection.agent,
+      model,
+      initial: history.initial,
+      messages: history.entries.map((entry) => entry.message),
+      tools: selection.tools
+    };
+  });
+  return Service21.of({ select, load, resolveModel, selectTitle, request });
+}));
+var MINIMAL_REASONING_VARIANTS = ["none", "minimal", "low"].map((id) => Model.VariantID.make(id));
+var node26 = makeLocationNode({
+  service: Service21,
+  layer,
+  deps: [
+    node66,
+    node69,
+    node85,
+    node27,
+    node51,
+    node29,
+    node78,
+    node32,
+    node34,
+    node33,
+    node44,
+    node30,
+    node65,
+    node28,
+    node38
+  ]
+});
+
+export { Service21, node26, exports_context };

package/dist/chunks/aisdk-native-c8k0fn6w.js

@@ -0,0 +1,335 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service71,
+  node75
+} from "./aisdk-native-ms882c9x.js";
+import {
+  cleanup3
+} from "./aisdk-native-gd4qta3r.js";
+import {
+  Service78,
+  args2,
+  node83
+} from "./aisdk-native-qx0n0hnh.js";
+import {
+  Service63,
+  node67
+} from "./aisdk-native-ra3qct3x.js";
+import {
+  Service33,
+  node37
+} from "./aisdk-native-23279rje.js";
+import {
+  SessionSchema2
+} from "./aisdk-native-y6f0p4jw.js";
+import {
+  latest2,
+  Service35,
+  node39
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  MAX_LINES2,
+  MAX_BYTES2
+} from "./aisdk-native-9jdakqgh.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/shell.ts
+var exports_shell4 = {};
+__export(exports_shell4, {
+  DIRECTORY: () => DIRECTORY2,
+  NotFoundError: () => NotFoundError4,
+  RETENTION: () => RETENTION2,
+  Service: () => Service32,
+  Shell: () => exports_shell4,
+  cleanup: () => cleanup2,
+  node: () => node36
+});
+import path from "path";
+import { Context, Deferred, Duration, Effect, Fiber, Latch, Layer, Schema, Schedule, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { produce } from "immer";
+import { Shell } from "@opencode/schema/shell";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode, makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+class NotFoundError4 extends Schema.TaggedError()("Shell.NotFoundError", {
+  id: Shell.ID
+}) {
+}
+var EXITED_LIMIT = 25;
+var RETENTION2 = Duration.days(7);
+var DIRECTORY2 = "shell";
+
+class Service32 extends Context.Service()("@opencode/Shell") {
+}
+var cleanup2 = Effect.fn("Shell.cleanup")(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY2);
+  const projects = yield* fs.readDirectoryEntries(directory).pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "directory")), Effect.orElseSucceed(() => []));
+  const files = yield* Effect.forEach(projects, (project) => fs.readDirectoryEntries(path.join(directory, project.name)).pipe(Effect.map((entries) => entries.flatMap((entry) => entry.type === "file" && /^sh_[0-9a-f]{12}.*\.out$/.test(entry.name) ? [path.join(directory, project.name, entry.name)] : [])), Effect.orElseSucceed(() => [])), { concurrency: 8 });
+  yield* cleanup3(fs, files.flat(), RETENTION2);
+});
+var cleanupLayer = Layer.effectDiscard(cleanup2().pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped));
+var cleanupNode = makeGlobalNode({
+  name: "shell-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var layer = () => Layer.effect(Service32, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service73;
+  const global = yield* Global.Service;
+  const shell = yield* Service78;
+  const environment = yield* Service71;
+  const hooks = yield* Service63;
+  const environments = yield* Service33;
+  const config = yield* Service35;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const commands = new Map;
+  const exitOrder = [];
+  const outputDir = path.join(global.data, DIRECTORY2, location.project.id);
+  const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"));
+  const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"));
+  yield* Effect.promise(() => mkdir(outputDir, { recursive: true }));
+  yield* Effect.addFinalizer(() => Effect.gen(function* () {
+    for (const command of commands.values()) {
+      if (command.timeoutFiber)
+        yield* Fiber.interrupt(command.timeoutFiber);
+      yield* Deferred.interrupt(command.done);
+    }
+    commands.clear();
+    exitOrder.length = 0;
+  }));
+  const require2 = Effect.fnUntraced(function* (id) {
+    const command = commands.get(id);
+    if (!command)
+      return yield* new NotFoundError4({ id });
+    return command;
+  });
+  const removeCommand = Effect.fnUntraced(function* (id) {
+    const command = commands.get(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    if (!command)
+      return;
+    commands.delete(id);
+    if (command.timeoutFiber)
+      yield* Fiber.interrupt(command.timeoutFiber);
+    yield* Deferred.fail(command.done, new NotFoundError4({ id }));
+    yield* Effect.promise(() => unlink(command.file).catch(() => {}));
+    yield* bus.publish(Shell.Event.Deleted, { id });
+  });
+  const remove = Effect.fn("Shell.remove")(function* (id) {
+    yield* require2(id);
+    yield* removeCommand(id);
+  });
+  const list = Effect.fn("Shell.list")(function* () {
+    return Array.from(commands.values()).filter((command) => command.info.status === "running").map((command) => command.info);
+  });
+  const get = Effect.fn("Shell.get")(function* (id) {
+    return (yield* require2(id)).info;
+  });
+  const wait = Effect.fn("Shell.wait")(function* (id) {
+    return yield* Deferred.await((yield* require2(id)).done);
+  });
+  const timeout = Effect.fn("Shell.timeout")(function* (id, duration) {
+    const command = yield* require2(id);
+    if (command.info.status !== "running" || !command.timeout)
+      return command.info;
+    yield* command.timeout(duration);
+    return command.info;
+  });
+  const output = Effect.fnUntraced(function* (id, input) {
+    const command = yield* require2(id);
+    const cursor = input?.cursor ?? 0;
+    const limit = input?.limit ?? 65536;
+    if (cursor >= command.size)
+      return { output: "", cursor: command.size, size: command.size, truncated: false };
+    const start = Math.max(0, cursor);
+    const length = Math.min(limit, command.size - start);
+    const buffer = Buffer.alloc(length);
+    const bytesRead = yield* Effect.promise(() => new Promise((resolve) => {
+      const stream = createReadStream(command.file, { start, end: start + length - 1 });
+      let offset = 0;
+      stream.on("data", (chunk) => {
+        const bytes = Buffer.from(chunk);
+        bytes.copy(buffer, offset);
+        offset += bytes.length;
+      });
+      stream.on("end", () => resolve(offset));
+      stream.on("error", () => resolve(0));
+    }));
+    return {
+      output: buffer.subarray(0, bytesRead).toString("utf8"),
+      cursor: start + bytesRead,
+      size: command.size,
+      truncated: false
+    };
+  });
+  const result = Effect.fn("Shell.result")(function* (started) {
+    const info = yield* wait(started.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed({ ...started, status: "killed", time: { ...started.time, completed: Date.now() } })));
+    const capture = yield* Effect.gen(function* () {
+      const limits = latest2(yield* config.entries(), "tool_output");
+      const maxLines = limits?.max_lines ?? MAX_LINES2;
+      const maxBytes = limits?.max_bytes ?? MAX_BYTES2;
+      const latest = yield* output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
+      const page = yield* output(info.id, { cursor: Math.max(0, latest.size - maxBytes), limit: maxBytes });
+      const lines = page.output.split(`
+`);
+      if (page.output.endsWith(`
+`))
+        lines.pop();
+      const truncated = latest.size > maxBytes || lines.length > maxLines;
+      const text = lines.length > maxLines ? lines.slice(-maxLines).join(`
+`) : page.output;
+      const notice = truncated ? `
+
+[output truncated; full output saved to: ${info.file}]` : "";
+      return { output: `${text || "(no output)"}${notice}`, truncated };
+    }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(undefined)));
+    return { info, capture };
+  });
+  const create = Effect.fn("Shell.create")(function* (input, before) {
+    const sessionID = input.metadata?.sessionID;
+    const sessionEnvironment = location.workspaceID === undefined && Schema.is(SessionSchema2.ID)(sessionID) ? yield* environments.get(sessionID) : undefined;
+    const invocation = {
+      command: input.command,
+      cwd: input.cwd ?? location.directory,
+      timeout: input.timeout,
+      shell: input.shell ?? (yield* shell.resolve({ priority: "config" })),
+      env: {
+        ...sessionEnvironment ?? process.env,
+        TERM: "xterm-256color",
+        OPENCODE_TERMINAL: "1"
+      }
+    };
+    yield* hooks.trigger("shell", "create.before", invocation);
+    if (before)
+      yield* before(invocation);
+    const id = Shell.ID.ascending();
+    const args = args2(invocation.shell, invocation.command);
+    const file = path.join(outputDir, `${id}.out`);
+    const info = {
+      id,
+      status: "running",
+      command: invocation.command,
+      cwd: invocation.cwd,
+      shell: invocation.shell,
+      file,
+      metadata: input.metadata ?? {},
+      time: { started: Date.now() }
+    };
+    const ready = Deferred.makeUnsafe();
+    runFork(Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(invocation.shell, args, {
+        cwd: invocation.cwd,
+        env: invocation.env,
+        stdin: "ignore",
+        detached: process.platform !== "win32",
+        forceKillAfter: Duration.seconds(3)
+      })).pipe(Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })));
+      const command = {
+        info: produce(info, (draft) => {
+          draft.pid = handle.pid;
+        }),
+        file,
+        size: 0,
+        done: Deferred.makeUnsafe()
+      };
+      commands.set(id, command);
+      const stream = createWriteStream(file);
+      const outputDone = Latch.makeUnsafe();
+      const pump = handle.all.pipe(Stream.runForEach((chunk) => Effect.sync(() => {
+        stream.write(chunk);
+        command.size += chunk.length;
+      })));
+      runFork(Effect.gen(function* () {
+        yield* pump.pipe(Effect.catch(() => Effect.void));
+        yield* Effect.promise(() => new Promise((resolve) => {
+          stream.end(() => resolve());
+        }));
+        yield* outputDone.open;
+      }));
+      yield* Effect.promise(() => new Promise((resolve) => {
+        stream.once("open", () => resolve());
+        stream.once("error", () => resolve());
+      }));
+      const finish = (status, exit, beforeWait = Effect.void) => Effect.gen(function* () {
+        if (command.info.status !== "running")
+          return;
+        command.info = produce(command.info, (draft) => {
+          draft.status = status;
+          if (exit !== undefined)
+            draft.exit = exit;
+          draft.time.completed = Date.now();
+        });
+        yield* beforeWait;
+        yield* outputDone.await;
+        yield* Deferred.succeed(command.done, command.info);
+        yield* bus.publish(Shell.Event.Exited, {
+          id,
+          ...exit !== undefined ? { exit } : {},
+          status
+        });
+        exitOrder.push(id);
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeCommand(oldest);
+        }
+        const timeoutFiber = command.timeoutFiber;
+        command.timeout = undefined;
+        command.timeoutFiber = undefined;
+        if (timeoutFiber)
+          yield* Fiber.interrupt(timeoutFiber);
+      });
+      command.timeout = (duration) => Effect.gen(function* () {
+        if (command.timeoutFiber)
+          yield* Fiber.interrupt(command.timeoutFiber);
+        command.timeoutFiber = undefined;
+        if (duration === 0 || command.info.status !== "running")
+          return;
+        command.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill({ forceKillAfter: Duration.seconds(3) }).pipe(Effect.catch(() => Effect.void))))));
+      });
+      yield* command.timeout(invocation.timeout);
+      runFork(handle.exitCode.pipe(Effect.flatMap((code) => finish("exited", code)), Effect.catch(() => finish("exited"))));
+      yield* bus.publish(Shell.Event.Created, { info });
+      yield* Deferred.succeed(ready, command);
+      yield* Deferred.await(command.done).pipe(Effect.catch(() => Effect.void));
+    })).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))));
+    const command = yield* Deferred.await(ready);
+    return command.info;
+  });
+  return Service32.of({ create, list, get, wait, result, timeout, output, remove });
+}));
+var node36 = makeLocationNode({
+  service: Service32,
+  layer: layer(),
+  deps: [
+    node84,
+    node78,
+    Global.node,
+    node83,
+    node75,
+    node67,
+    node37,
+    node39,
+    cleanupNode
+  ]
+});
+
+export { NotFoundError4, RETENTION2, DIRECTORY2, Service32, cleanup2, node36, exports_shell4 };