@vantran-se/openchamber-web 1.24.4 → 2.0.1

package/server/lib/opencode/lifecycle.test.js

@@ -102,7 +102,8 @@ const createRuntime = (overrides = {}, stateOverrides = {}, envOverrides = {}) =
     waitForReady: vi.fn(async () => true),
     normalizeApiPrefix: vi.fn(() => ''),
     applyOpencodeBinaryFromSettings: vi.fn(async () => null),
-    ensureOpencodeCliEnv: vi.fn(),
+    checkOpenCodeBinary: async () => '2.0.14',
+  ensureOpencodeCliEnv: vi.fn(),
     ensureLocalOpenCodeServerPassword: vi.fn(async () => 'password'),
     resolveManagedOpenCodeLaunchSpec: vi.fn((binary) => ({ binary, args: [], wrapperType: null })),
     setOpenCodePort: vi.fn((port) => {
@@ -114,6 +115,8 @@ const createRuntime = (overrides = {}, stateOverrides = {}, envOverrides = {}) =
     clearResolvedOpenCodeBinary: vi.fn(),
     buildAugmentedPath: vi.fn(() => '/home/user/.bun/bin:/usr/local/bin:/usr/bin'),
     buildManagedOpenCodePath: vi.fn(() => '/home/user/.bun/bin:/usr/local/bin:/usr/bin'),
+    // Never let a test touch the real `~/.local/share/opencode/opencode.db`.
+    topUpV1SessionMigration: vi.fn(() => ({ status: 'skipped', missing: 0, revisited: 0, reason: 'no-database' })),
     getManagedOpenCodeShellEnvSnapshot: vi.fn(() => ({
       PATH: '/home/user/.bun/bin:/usr/local/bin:/usr/bin',
       SHELL_ONLY: 'yes',
@@ -158,7 +161,7 @@ describe('OpenCode lifecycle', () => {
   it('records an authoritative ready terminal event for external startup', async () => {
     globalThis.fetch = vi.fn(async () => ({
       ok: true,
-      json: async () => ({ healthy: true }),
+      json: async () => ({ version: '2.0.15', pid: 1, urls: [], paths: { tmp: '/tmp' } }),
     }));
     const runtime = createRuntime({
       env: {
@@ -190,7 +193,7 @@ describe('OpenCode lifecycle', () => {
   it('recovers an external OPENCODE_HOST connection using its configured endpoint', async () => {
     const fetchMock = vi.fn(async () => ({
       ok: true,
-      json: async () => ({ healthy: true }),
+      json: async () => ({ version: '2.0.15', pid: 1, urls: [], paths: { tmp: '/tmp' } }),
     }));
     globalThis.fetch = fetchMock;
     const runtime = createRuntime({}, {
@@ -206,7 +209,7 @@ describe('OpenCode lifecycle', () => {
     await runtime.restartOpenCode();
 
     expect(fetchMock).toHaveBeenCalledWith(
-      'http://seamus:4095/global/health',
+      'http://seamus:4095/api/info',
       expect.objectContaining({ method: 'GET' }),
     );
     expect(runtime.testState.openCodePort).toBe(4095);
@@ -240,7 +243,7 @@ describe('OpenCode lifecycle', () => {
   it('warms recently used directories after a successful bootstrap', async () => {
     const fetchMock = vi.fn(async () => ({
       ok: true,
-      json: async () => ({ healthy: true }),
+      json: async () => ({ version: '2.0.15', pid: 1, urls: [], paths: { tmp: '/tmp' } }),
     }));
     globalThis.fetch = fetchMock;
     const runtime = createRuntime({
@@ -260,10 +263,10 @@ describe('OpenCode lifecycle', () => {
 
     const warmupUrls = fetchMock.mock.calls
       .map(([url]) => String(url))
-      .filter((url) => url.includes('/session/status'));
+      .filter((url) => url.includes('/api/session?'));
     expect(warmupUrls).toEqual([
-      'http://127.0.0.1:45678/session/status?directory=%2Ftmp%2Fworktree-a',
-      'http://127.0.0.1:45678/session/status?directory=%2Ftmp%2Fproject-b',
+      'http://127.0.0.1:45678/api/session?directory=%2Ftmp%2Fworktree-a&limit=1',
+      'http://127.0.0.1:45678/api/session?directory=%2Ftmp%2Fproject-b&limit=1',
     ]);
   });
 
@@ -876,6 +879,28 @@ describe('OpenCode lifecycle', () => {
     expect(spawnMock).toHaveBeenCalledTimes(2);
     await server.close();
   });
+
+  it('tops up the v1 session migration before spawning managed OpenCode', async () => {
+    const calls = [];
+    const topUpV1SessionMigration = vi.fn(() => {
+      calls.push('top-up');
+      return { status: 'scheduled', missing: 3, revisited: 0 };
+    });
+    spawnMock.mockImplementation(() => {
+      calls.push('spawn');
+      const child = createMockChild();
+      queueMicrotask(() => child.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n'));
+      return child;
+    });
+    globalThis.fetch = vi.fn(async () => ({ ok: false }));
+
+    const runtime = createRuntime({ topUpV1SessionMigration });
+    await runtime.startOpenCode();
+
+    expect(topUpV1SessionMigration).toHaveBeenCalledTimes(1);
+    expect(calls).toEqual(['top-up', 'spawn']);
+  });
+
 });
 
 describe('killProcessOnPort on Windows', () => {
@@ -944,3 +969,50 @@ describe('killProcessOnPort on Windows', () => {
     expect(spawnSyncMock).not.toHaveBeenCalledWith('taskkill', expect.anything(), expect.anything());
   });
 });
+
+it('shares the managed CLI preflight with desktop while startup is pending', async () => {
+  let finish;
+  let entered;
+  const checking = new Promise(resolve => { entered = resolve; });
+  const check = new Promise(resolve => { finish = resolve; });
+  let checks = 0;
+  const runtime = createRuntime({
+    checkOpenCodeBinary: () => { checks += 1; entered(); return check; },
+    ensureOpencodeCliEnv: () => '/tmp/opencode',
+  });
+  spawnMock.mockImplementation(() => {
+    const child = createMockChild();
+    queueMicrotask(() => child.stdout.emit('data', 'opencode server listening on http://127.0.0.1:45678\n'));
+    return child;
+  });
+  expect(await runtime.getManagedOpenCodePreflight()).toBe(false);
+  const starting = runtime.startOpenCode();
+  await checking;
+  const desktopVerdict = runtime.getManagedOpenCodePreflight();
+  expect(runtime.testState.isOpenCodeReady).toBe(false);
+  finish('2.0.15');
+  expect(await desktopVerdict).toBe(true);
+  expect(checks).toBe(1);
+  const server = await starting;
+  try {
+    expect(await runtime.getManagedOpenCodePreflight()).toBe(true);
+    runtime.testState.isExternalOpenCode = true;
+    expect(await runtime.getManagedOpenCodePreflight()).toBe(false);
+    runtime.testState.isExternalOpenCode = false;
+    runtime.testState.isShuttingDown = true;
+    expect(await runtime.getManagedOpenCodePreflight()).toBe(false);
+  } finally {
+    await server.close();
+  }
+});
+
+it('a rejected CLI preflight never permits desktop bootstrap', async () => {
+  const runtime = createRuntime({
+    checkOpenCodeBinary: async () => {
+      throw Object.assign(new Error('Unsupported CLI'), { code: 'OPENCODE_BINARY_INVALID' });
+    },
+  });
+  await expect(runtime.startOpenCode()).rejects.toThrow('Unsupported CLI');
+  expect(await runtime.getManagedOpenCodePreflight()).toBe(false);
+  expect(spawnMock).not.toHaveBeenCalled();
+});

package/server/lib/opencode/login-shell-env.js

@@ -0,0 +1,27 @@
+/**
+ * Handoff of a login-shell environment snapshot from an embedding host.
+ *
+ * The server snapshots the user's login shell (`$SHELL -lic 'env -0'`) at
+ * import time to learn the PATH a Finder- or Dock-launched process never
+ * inherits. Desktop already runs the same probe asynchronously while its
+ * window comes up; running it again here would block the Electron main
+ * thread for as long as the user's shell startup files take, a second time.
+ * A host that has a snapshot hands it over before importing the server, and
+ * the server uses it instead of probing. `null` means the host probed and got
+ * nothing: the server does not retry, because that retry would be
+ * synchronous and bounded only by the probe timeout.
+ *
+ * Kept in this module rather than in the environment on purpose: the
+ * snapshot is the user's full shell environment, secrets included, and
+ * process.env is inherited by every child the server spawns.
+ */
+
+let provided;
+
+// `snapshot` is the parsed `env -0` map, or null when the host's probe failed.
+export const provideLoginShellEnvSnapshot = (snapshot) => {
+  provided = snapshot ? { ...snapshot } : null;
+};
+
+// `undefined` when no host provided one, so the server probes itself.
+export const providedLoginShellEnvSnapshot = () => provided;

package/server/lib/opencode/managed-config-file.js

@@ -0,0 +1,119 @@
+import { appendManagedPlugin } from './managed-plugin-config.js';
+
+export const MANAGED_CONFIG_FILE_NAME = 'opencode.managed.json';
+
+/**
+ * The managed OpenCode config layer.
+ *
+ * OpenCode 2 watches every config source it reads, including the file named by
+ * the `OPENCODE_CONFIG` environment variable, and reloads its plugin list when
+ * that file changes. Writing OpenChamber's own plugin entries into a file we
+ * own therefore makes toggling a managed tool take effect in the running
+ * process — where `OPENCODE_CONFIG_CONTENT` (an environment variable) could
+ * only ever change across a restart.
+ *
+ * The file is OpenChamber-owned and holds nothing but `plugins`. It sits above
+ * the user's global `opencode.json` and below their project config, so it never
+ * shadows a project-level choice.
+ *
+ * When the user's own environment already sets `OPENCODE_CONFIG`, that file is
+ * theirs: OpenChamber does not hijack it and falls back to merging its plugins
+ * into `OPENCODE_CONFIG_CONTENT`, which keeps the old restart requirement for
+ * managed-tool toggles.
+ *
+ * @param {object} dependencies
+ * @param {typeof import('node:fs/promises')} dependencies.fsPromises
+ * @param {typeof import('node:path')} dependencies.path
+ * @param {string} dependencies.dataDir OpenChamber data directory
+ * @param {NodeJS.ProcessEnv} [dependencies.env] environment the managed child inherits
+ * @param {object|null} [dependencies.agentToolRuntime]
+ * @param {() => Promise<object|null>} dependencies.readSettings
+ * @param {() => boolean} dependencies.isAgentMemoryAvailable
+ */
+export const createManagedConfigRuntime = ({
+  fsPromises,
+  path,
+  dataDir,
+  env = process.env,
+  agentToolRuntime = null,
+  readSettings,
+  isAgentMemoryAvailable,
+}) => {
+  const filePath = path.join(dataDir, MANAGED_CONFIG_FILE_NAME);
+
+  /** The user owns `OPENCODE_CONFIG` when their environment already set it. */
+  const ownsConfigFile = () => (env.OPENCODE_CONFIG ?? '').trim().length === 0;
+
+  const writeConfigFile = async (pluginDirectories) => {
+    await fsPromises.mkdir(dataDir, { recursive: true });
+    const text = `${JSON.stringify({ plugins: pluginDirectories }, null, 2)}\n`;
+    // Temp + rename: OpenCode reacts to the write immediately, and a partial
+    // read would make it drop every managed plugin until the next change.
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      await fsPromises.writeFile(tmp, text, { encoding: 'utf8', mode: 0o600 });
+      await fsPromises.rename(tmp, filePath);
+    } catch (error) {
+      await fsPromises.rm(tmp, { force: true }).catch(() => {});
+      throw error;
+    }
+  };
+
+  /**
+   * Materialize the plugins the current settings ask for and return their
+   * directories in load order. Directories exist on disk before the config
+   * file names them.
+   */
+  const materializeEnabledPlugins = async () => {
+    const settings = await Promise.resolve(readSettings()).catch(() => null);
+    const includeControl = settings?.agentControlToolEnabled !== false;
+    const includeWeb = settings?.agentWebToolEnabled !== false;
+    const includeMemory = isAgentMemoryAvailable() && settings?.agentMemoryToolEnabled === true;
+
+    const directories = [];
+    if (agentToolRuntime && (includeControl || includeWeb || includeMemory)) {
+      directories.push(await agentToolRuntime.materializePlugin({ includeControl, includeWeb, includeMemory }));
+    }
+    return directories;
+  };
+
+  /**
+   * Environment for a managed OpenCode child: the callback URL and per-child
+   * token are always present, so a tool enabled later in the session can still
+   * call back without a restart.
+   */
+  const buildManagedChildEnv = async () => {
+    const directories = await materializeEnabledPlugins();
+    const childEnv = agentToolRuntime ? agentToolRuntime.createChildEnv() : {};
+    if (ownsConfigFile()) {
+      await writeConfigFile(directories);
+      return { ...childEnv, OPENCODE_CONFIG: filePath };
+    }
+    if (directories.length === 0) return childEnv;
+    let content = env.OPENCODE_CONFIG_CONTENT;
+    for (const directory of directories) {
+      content = appendManagedPlugin(content, directory, 'managed plugin');
+    }
+    return { ...childEnv, OPENCODE_CONFIG_CONTENT: content };
+  };
+
+  /**
+   * Rewrite the managed config file after a managed-plugin setting changed, so
+   * the running OpenCode picks the new plugin list up. A no-op when the user
+   * owns `OPENCODE_CONFIG`; those installs still need a restart.
+   *
+   * @returns {Promise<{updated: boolean, reason?: string}>}
+   */
+  const refreshManagedConfigFile = async () => {
+    if (!ownsConfigFile()) return { updated: false, reason: 'external-config' };
+    await writeConfigFile(await materializeEnabledPlugins());
+    return { updated: true };
+  };
+
+  return {
+    filePath,
+    ownsConfigFile,
+    buildManagedChildEnv,
+    refreshManagedConfigFile,
+  };
+};

package/server/lib/opencode/managed-config-file.test.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createManagedConfigRuntime, MANAGED_CONFIG_FILE_NAME } from './managed-config-file.js';
+
+const temporaryDirectories = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true, force: true })));
+});
+
+const createHarness = async ({ settings = {}, env = {}, memoryAvailable = true } = {}) => {
+  const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'openchamber-managed-config-'));
+  temporaryDirectories.push(dataDir);
+  const agentToolRuntime = {
+    pluginDirectory: path.join(dataDir, 'agent-tool', 'openchamber-agent-tool'),
+    materializePlugin: vi.fn(async (flags) => {
+      await fs.mkdir(agentToolRuntime.pluginDirectory, { recursive: true });
+      await fs.writeFile(path.join(agentToolRuntime.pluginDirectory, 'flags.json'), JSON.stringify(flags));
+      return agentToolRuntime.pluginDirectory;
+    }),
+    createChildEnv: vi.fn(() => ({
+      OPENCHAMBER_AGENT_TOOL_URL: 'http://127.0.0.1:3901/api/openchamber/agent-tool',
+      OPENCHAMBER_AGENT_TOOL_TOKEN: 'token',
+    })),
+  };
+  const current = { settings };
+  const runtime = createManagedConfigRuntime({
+    fsPromises: fs,
+    path,
+    dataDir,
+    env,
+    agentToolRuntime,
+    readSettings: () => current.settings,
+    isAgentMemoryAvailable: () => memoryAvailable,
+  });
+  const readConfigFile = async () => JSON.parse(await fs.readFile(path.join(dataDir, MANAGED_CONFIG_FILE_NAME), 'utf8'));
+  return { dataDir, runtime, agentToolRuntime, current, readConfigFile };
+};
+
+describe('managed OpenCode config file', () => {
+  it('points the child at a config file listing the enabled plugins', async () => {
+    const { dataDir, runtime, readConfigFile } = await createHarness({
+      settings: {},
+    });
+
+    const childEnv = await runtime.buildManagedChildEnv();
+
+    expect(childEnv.OPENCODE_CONFIG).toBe(path.join(dataDir, MANAGED_CONFIG_FILE_NAME));
+    expect(childEnv.OPENCODE_CONFIG_CONTENT).toBeUndefined();
+    expect(childEnv.OPENCHAMBER_AGENT_TOOL_TOKEN).toBe('token');
+    expect(await readConfigFile()).toEqual({
+      plugins: [path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
+    });
+  });
+
+  it('materializes every listed plugin directory before naming it', async () => {
+    const { runtime, readConfigFile } = await createHarness({ settings: {} });
+
+    await runtime.buildManagedChildEnv();
+
+    for (const directory of (await readConfigFile()).plugins) {
+      expect((await fs.stat(directory)).isDirectory()).toBe(true);
+    }
+  });
+
+  it('keeps the callback token in the child env while every tool is off', async () => {
+    const { runtime, agentToolRuntime, readConfigFile } = await createHarness({
+      settings: { agentControlToolEnabled: false, agentWebToolEnabled: false, agentMemoryToolEnabled: false },
+    });
+
+    const childEnv = await runtime.buildManagedChildEnv();
+
+    expect(agentToolRuntime.materializePlugin).not.toHaveBeenCalled();
+    expect(await readConfigFile()).toEqual({ plugins: [] });
+    // A tool switched on later reaches a process that can already call back.
+    expect(childEnv.OPENCHAMBER_AGENT_TOOL_TOKEN).toBe('token');
+  });
+
+  it('rewrites the file when a tool is turned off, without a new token', async () => {
+    const { dataDir, runtime, current, agentToolRuntime, readConfigFile } = await createHarness({
+      settings: {},
+    });
+    await runtime.buildManagedChildEnv();
+
+    current.settings = { agentControlToolEnabled: false, agentWebToolEnabled: false };
+    expect(await runtime.refreshManagedConfigFile()).toEqual({ updated: true });
+
+    const { plugins } = await readConfigFile();
+    expect(plugins).toEqual([]);
+    expect(agentToolRuntime.createChildEnv).toHaveBeenCalledTimes(1);
+  });
+
+  it('turns a tool back on without a restart', async () => {
+    const { runtime, current, agentToolRuntime, readConfigFile } = await createHarness({
+      settings: { agentControlToolEnabled: false, agentWebToolEnabled: false },
+    });
+    await runtime.buildManagedChildEnv();
+
+    current.settings = { agentControlToolEnabled: false, agentWebToolEnabled: true };
+    await runtime.refreshManagedConfigFile();
+
+    expect((await readConfigFile()).plugins).toHaveLength(1);
+    expect(agentToolRuntime.materializePlugin).toHaveBeenCalledWith({
+      includeControl: false,
+      includeWeb: true,
+      includeMemory: false,
+    });
+  });
+
+  it('leaves a config file the user owns alone and keeps the restart requirement', async () => {
+    const { dataDir, runtime } = await createHarness({
+      settings: {},
+      env: { OPENCODE_CONFIG: '/home/user/opencode.json', OPENCODE_CONFIG_CONTENT: '{"model":"test/model"}' },
+    });
+
+    const childEnv = await runtime.buildManagedChildEnv();
+
+    expect(childEnv.OPENCODE_CONFIG).toBeUndefined();
+    expect(JSON.parse(childEnv.OPENCODE_CONFIG_CONTENT)).toEqual({
+      model: 'test/model',
+      plugins: [path.join(dataDir, 'agent-tool', 'openchamber-agent-tool')],
+    });
+    await expect(fs.stat(path.join(dataDir, MANAGED_CONFIG_FILE_NAME))).rejects.toThrow();
+    expect(await runtime.refreshManagedConfigFile()).toEqual({ updated: false, reason: 'external-config' });
+  });
+
+  it('leaves no temp file behind and never publishes a partial list', async () => {
+    const { dataDir, runtime } = await createHarness({ settings: {} });
+
+    await runtime.buildManagedChildEnv();
+    await runtime.refreshManagedConfigFile();
+
+    const entries = await fs.readdir(dataDir);
+    expect(entries.filter((entry) => entry.includes('.tmp-'))).toEqual([]);
+    expect(entries).toContain(MANAGED_CONFIG_FILE_NAME);
+  });
+
+  it('ignores the memory tool while the feature is unavailable', async () => {
+    const { runtime, agentToolRuntime, readConfigFile } = await createHarness({
+      settings: { agentControlToolEnabled: false, agentWebToolEnabled: false, agentMemoryToolEnabled: true },
+      memoryAvailable: false,
+    });
+
+    await runtime.buildManagedChildEnv();
+
+    expect(agentToolRuntime.materializePlugin).not.toHaveBeenCalled();
+    expect(await readConfigFile()).toEqual({ plugins: [] });
+  });
+});

package/server/lib/opencode/managed-plugin-config.js

@@ -2,34 +2,54 @@ import { parse as parseJsonc } from 'jsonc-parser';
 
 const isJsonObject = (value) => value !== null && value !== undefined && Object.getPrototypeOf(value) === Object.prototype;
 
+const matchesEntry = (value, pluginDirectory) => (
+  value === pluginDirectory || (Array.isArray(value) && value[0] === pluginDirectory)
+);
+
 /**
- * Append a managed OpenChamber plugin to the `plugin` list of an
+ * Append a managed OpenChamber plugin to the `plugins` list of an
  * `OPENCODE_CONFIG_CONTENT` value.
  *
- * Existing entries are preserved; an earlier entry for the same URL is dropped
- * so a restart never registers the same plugin twice. Every managed plugin
- * (agent tools, system prompt optimizer) goes through this one
- * merge so they compose in any order.
+ * OpenCode 2 loads a configured plugin from a DIRECTORY that carries a
+ * `package.json` resolving an entrypoint; a path to a single `.js` file is
+ * rejected with "configured plugin path must be a directory". So the value
+ * merged here is an absolute directory path, not a `file://` URL.
+ *
+ * Existing entries are preserved and an earlier entry for the same directory is
+ * dropped, so a restart never registers the same plugin twice. A legacy
+ * `plugin` key is folded into `plugins` and removed: OpenCode still decodes it,
+ * but keeping two keys would mean two places to dedupe against.
+ *
+ * This is the FALLBACK path only, taken when the user's own environment owns
+ * `OPENCODE_CONFIG`. Otherwise managed plugins are published through the
+ * watched config file in `managed-config-file.js`, which is what makes a
+ * managed-tool toggle apply without a restart.
  *
  * @param {string | undefined} rawConfig the current `OPENCODE_CONFIG_CONTENT`, JSONC or unset
- * @param {string} pluginUrl `file://` URL of the materialized plugin
+ * @param {string} pluginDirectory absolute path of the materialized plugin directory
  * @param {string} purpose short noun phrase for the error message, e.g. "managed tool"
  * @returns {string} the merged config as JSON
  */
-export const appendManagedPlugin = (rawConfig, pluginUrl, purpose) => {
+export const appendManagedPlugin = (rawConfig, pluginDirectory, purpose) => {
   const errors = [];
   const text = (rawConfig ?? '').trim();
   const parsed = text ? parseJsonc(text, errors, { allowTrailingComma: true }) : {};
   if (errors.length > 0 || !isJsonObject(parsed)) {
     throw new Error(`OPENCODE_CONFIG_CONTENT must contain a valid JSON object before OpenChamber can inject its ${purpose}`);
   }
-  if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) {
-    throw new Error(`OPENCODE_CONFIG_CONTENT plugin must be an array before OpenChamber can inject its ${purpose}`);
+  for (const key of ['plugin', 'plugins']) {
+    if (parsed[key] !== undefined && !Array.isArray(parsed[key])) {
+      throw new Error(`OPENCODE_CONFIG_CONTENT ${key} must be an array before OpenChamber can inject its ${purpose}`);
+    }
   }
-  const configured = Array.isArray(parsed.plugin) ? parsed.plugin : [];
-  parsed.plugin = [
-    ...configured.filter((value) => value !== pluginUrl && (!Array.isArray(value) || value[0] !== pluginUrl)),
-    pluginUrl,
+  const configured = [
+    ...(Array.isArray(parsed.plugin) ? parsed.plugin : []),
+    ...(Array.isArray(parsed.plugins) ? parsed.plugins : []),
+  ];
+  delete parsed.plugin;
+  parsed.plugins = [
+    ...configured.filter((value) => !matchesEntry(value, pluginDirectory)),
+    pluginDirectory,
   ];
   return JSON.stringify(parsed);
 };