cyberia 3.2.9 → 3.2.22

package/test/deploy-monitor.test.js

@@ -0,0 +1,251 @@
+/**
+ * @module deploy-monitor.test
+ * @description End-to-end test of the two-phase deployment readiness contract
+ * between the in-pod runtime (`start.js` / `runtime-status.js`) and the CD-runner
+ * monitor (`Underpost.monitor.monitorReadyRunner`), exercised as real OS
+ * processes coordinating through the shared underpost env file and a real HTTP
+ * internal status endpoint.
+ *
+ * Contract under test:
+ *
+ *   - The in-pod runtime publishes only `container-status` (Phase 2) and serves
+ *     it over `GET /_internal/status`. It never propagates an exit code.
+ *
+ *   - monitorReadyRunner (CD runner) confirms BOTH phases before exiting 0:
+ *       Phase 1 — Kubernetes pod `Ready` condition (kubectl get pod -o json).
+ *       Phase 2 — runtime `running-deployment` read over HTTP via
+ *                 `kubectl port-forward` to the internal endpoint.
+ *     It throws (→ exit 1) on explicit runtime `error`, and returns (→ exit 0)
+ *     only once both phases are satisfied.
+ *
+ * The cluster surface is supplied by fake `sudo`/`kubectl` binaries on PATH:
+ *   - `get pods` / `get pod -o json` report one pod whose Ready condition is
+ *     driven by FAKE_POD_READY.
+ *   - `port-forward` is a no-op sleep; the monitor's HTTP GET reaches a REAL
+ *     internal status server bound in this test process (localPort == port),
+ *     which reads the same env file the runtime writes.
+ *
+ * The env file is redirected under a temp `npm_config_prefix`, so the test
+ * needs no cluster, no root, and never touches the machine's global install.
+ *
+ * Uses 'chai' for assertions.
+ */
+
+import { expect } from 'chai';
+import fs from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import Underpost from '../src/index.js';
+import { shellExec } from '../src/server/process.js';
+import { startInternalStatusServer, stopInternalStatusServer } from '../src/server/runtime-status.js';
+
+const node = process.execPath;
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const DEPLOY_ID = 'dd-test';
+const ENV = 'production';
+const TRAFFIC = 'green';
+const POD_NAME = `${DEPLOY_ID}-${ENV}-${TRAFFIC}-pod`;
+const RUNNING_STATUS = `${DEPLOY_ID}-${ENV}-running-deployment`;
+const INIT_STATUS = `${DEPLOY_ID}-${ENV}-initializing-deployment`;
+const BUILD_STATUS = `${DEPLOY_ID}-${ENV}-build-deployment`;
+
+const INTERNAL_PORT = 39517; // internal status endpoint (real server bound here)
+const CLOSED_PORT = 39518; // no server — used to force a transport failure
+
+describe('Deploy monitor — two-phase state machine (e2e, real HTTP transport)', function () {
+  this.timeout(60000);
+
+  let prevPrefix;
+  let tmpPrefix;
+  let fakeBinDir;
+  let envFile;
+  let monitorScriptPath;
+
+  before(() => {
+    prevPrefix = process.env.npm_config_prefix;
+    tmpPrefix = fs.mkdtempSync(path.join(os.tmpdir(), 'underpost-e2e-'));
+    process.env.npm_config_prefix = tmpPrefix;
+
+    Underpost.env.set('container-status', 'init');
+    const npmRoot = shellExec('npm root -g', { stdout: true, silent: true, disableLog: true }).trim();
+    envFile = path.join(npmRoot, 'underpost', '.env');
+
+    // Real in-pod internal status server: serves container-status from the same
+    // env file the runtime writes. Bound in this test process; the monitor's
+    // port-forward tunnel (localPort == INTERNAL_PORT) resolves straight to it.
+    process.env.UNDERPOST_INTERNAL_PORT = String(INTERNAL_PORT);
+    startInternalStatusServer(INTERNAL_PORT);
+
+    fakeBinDir = path.join(tmpPrefix, 'fakebin');
+    fs.ensureDirSync(fakeBinDir);
+
+    const sudoPath = path.join(fakeBinDir, 'sudo');
+    fs.writeFileSync(
+      sudoPath,
+      `#!/usr/bin/env bash
+while [[ "$1" == -* || "$1" == "--" ]]; do shift; done
+exec "$@"
+`,
+    );
+
+    const kubectlPath = path.join(fakeBinDir, 'kubectl');
+    fs.writeFileSync(
+      kubectlPath,
+      `#!/usr/bin/env bash
+verb="$1"; kind="$2"
+if [[ "$verb" == "get" && "$kind" == "pods" ]]; then
+  printf 'NAME READY STATUS RESTARTS AGE\\n'
+  printf '%s 1/1 Running 0 1m\\n' "$POD_NAME"
+  exit 0
+fi
+if [[ "$verb" == "get" && "$kind" == "pod" ]]; then
+  printf '{"status":{"conditions":[{"type":"Ready","status":"%s"}]}}\\n' "\${FAKE_POD_READY:-True}"
+  exit 0
+fi
+if [[ "$verb" == "port-forward" ]]; then
+  sleep 30
+  exit 0
+fi
+if [[ "$verb" == "exec" ]]; then
+  grep -E '^container-status=' "$UNDERPOST_ENV_FILE" 2>/dev/null | tail -n1 | sed -E 's/^container-status=//'
+  exit 0
+fi
+exit 0
+`,
+    );
+    fs.chmodSync(sudoPath, 0o755);
+    fs.chmodSync(kubectlPath, 0o755);
+
+    monitorScriptPath = path.join(tmpPrefix, 'monitor-ready.mjs');
+    fs.writeFileSync(
+      monitorScriptPath,
+      `import Underpost from ${JSON.stringify(pathToFileURL(path.join(repoRoot, 'src/index.js')).href)};
+const options = {};
+if (process.env.MON_READY_GATE) options.readyGate = process.env.MON_READY_GATE;
+if (process.env.MON_TRANSPORT) options.statusTransport = process.env.MON_TRANSPORT;
+try {
+  await Underpost.monitor.monitorReadyRunner(${JSON.stringify(DEPLOY_ID)}, ${JSON.stringify(ENV)}, ${JSON.stringify(
+    TRAFFIC,
+  )}, [], 'default', options);
+  process.exit(0);
+} catch (_) {
+  process.exit(1);
+}
+`,
+    );
+  });
+
+  after(async () => {
+    await stopInternalStatusServer();
+    delete process.env.UNDERPOST_INTERNAL_PORT;
+    if (prevPrefix === undefined) delete process.env.npm_config_prefix;
+    else process.env.npm_config_prefix = prevPrefix;
+    fs.removeSync(tmpPrefix);
+  });
+
+  beforeEach(() => {
+    // Deploy in flight: app not yet reporting running.
+    Underpost.env.set('container-status', INIT_STATUS);
+  });
+
+  // Spawns the real monitorReadyRunner with the fake cluster on PATH; resolves
+  // with its exit code. `overrides` inject deterministic timing / target port.
+  const spawnMonitor = (overrides = {}) =>
+    new Promise((resolve) => {
+      const envVars = {
+        PATH: `${fakeBinDir}:${process.env.PATH}`,
+        UNDERPOST_ENV_FILE: envFile,
+        POD_NAME,
+        npm_config_prefix: tmpPrefix,
+        UNDERPOST_INTERNAL_PORT: String(INTERNAL_PORT),
+        // Pin the tunnel's local port so the no-op fake port-forward + the real
+        // internal server (bound to INTERNAL_PORT in this process) resolve to the
+        // same address the monitor's HTTP GET targets.
+        UNDERPOST_PF_LOCAL_PORT: String(INTERNAL_PORT),
+        UNDERPOST_MONITOR_DELAY_MS: '100',
+        UNDERPOST_MONITOR_MAX_ITERATIONS: '60',
+        UNDERPOST_PF_ATTEMPTS: '3',
+        FAKE_POD_READY: 'True',
+        ...overrides,
+      };
+      const prefix = Object.entries(envVars)
+        .map(([k, v]) => `${k}="${v}"`)
+        .join(' ');
+      shellExec(`${prefix} ${node} ${monitorScriptPath}`, {
+        async: true,
+        silent: true,
+        disableLog: true,
+        callback: (code) => resolve(code),
+      });
+    });
+
+  it('success (default exec transport): both phases satisfied → monitor exits 0', async () => {
+    Underpost.env.set('container-status', RUNNING_STATUS);
+    const code = await spawnMonitor({ FAKE_POD_READY: 'True' });
+    expect(code).to.equal(0);
+  });
+
+  it('success (opt-in http transport): both phases satisfied → monitor exits 0', async () => {
+    Underpost.env.set('container-status', RUNNING_STATUS);
+    const code = await spawnMonitor({ FAKE_POD_READY: 'True', MON_TRANSPORT: 'http' });
+    expect(code).to.equal(0);
+  });
+
+  it('runtime failure: container-status=error → monitor exits 1', async () => {
+    const monitorExit = spawnMonitor({ FAKE_POD_READY: 'True' });
+    Underpost.env.set('container-status', 'error');
+    expect(await monitorExit).to.equal(1);
+  });
+
+  it('readiness mismatch: runtime running but pod not Ready → never succeeds (exits 1)', async () => {
+    // Phase 2 satisfied, Phase 1 not: success requires BOTH, so it must time out.
+    Underpost.env.set('container-status', RUNNING_STATUS);
+    const code = await spawnMonitor({ FAKE_POD_READY: 'False', UNDERPOST_MONITOR_MAX_ITERATIONS: '4' });
+    expect(code).to.equal(1);
+  });
+
+  it('transport failure (http): endpoint unreachable is never success (exits 1)', async () => {
+    // Opt into http and point the monitor at a port with no internal server; the
+    // HTTP read always fails, so runtime readiness is never confirmed → timeout.
+    Underpost.env.set('container-status', RUNNING_STATUS);
+    const code = await spawnMonitor({
+      MON_TRANSPORT: 'http',
+      UNDERPOST_INTERNAL_PORT: String(CLOSED_PORT),
+      UNDERPOST_PF_LOCAL_PORT: String(CLOSED_PORT),
+      UNDERPOST_MONITOR_MAX_ITERATIONS: '3',
+    });
+    expect(code).to.equal(1);
+  });
+
+  it('timeout: runtime stuck initializing → monitor exits 1', async () => {
+    Underpost.env.set('container-status', INIT_STATUS);
+    const code = await spawnMonitor({ FAKE_POD_READY: 'True', UNDERPOST_MONITOR_MAX_ITERATIONS: '4' });
+    expect(code).to.equal(1);
+  });
+
+  it('regression: advanced pod whose runtime status falls back → monitor exits 1', async () => {
+    // Pod advances past build, then its reported status regresses (pod restart);
+    // the monitor must treat this as a failure rather than wait it out.
+    Underpost.env.set('container-status', INIT_STATUS);
+    const monitorExit = spawnMonitor({ FAKE_POD_READY: 'False', UNDERPOST_MONITOR_MAX_ITERATIONS: '120' });
+    await new Promise((r) => setTimeout(r, 1500));
+    Underpost.env.set('container-status', BUILD_STATUS);
+    expect(await monitorExit).to.equal(1);
+  });
+
+  // Custom instances (cyberia-*) gate on K8s Ready and read status via exec;
+  // their runtime never stamps `running-deployment` (stays `initializing`).
+  it('instance (kubernetes gate + exec): K8s Ready with initializing status → exits 0', async () => {
+    Underpost.env.set('container-status', INIT_STATUS);
+    const code = await spawnMonitor({ FAKE_POD_READY: 'True', MON_READY_GATE: 'kubernetes', MON_TRANSPORT: 'exec' });
+    expect(code).to.equal(0);
+  });
+
+  it('instance (kubernetes gate + exec): container-status=error → exits 1', async () => {
+    const monitorExit = spawnMonitor({ FAKE_POD_READY: 'True', MON_READY_GATE: 'kubernetes', MON_TRANSPORT: 'exec' });
+    Underpost.env.set('container-status', 'error');
+    expect(await monitorExit).to.equal(1);
+  });
+});

package/bin/file.js

@@ -1,202 +0,0 @@
-import fs from 'fs-extra';
-
-import { loggerFactory } from '../src/server/logger.js';
-import {
-  cap,
-  getCapVariableName,
-  getDirname,
-  newInstance,
-  uniqueArray,
-} from '../src/client/components/core/CommonJs.js';
-import { shellCd, shellExec } from '../src/server/process.js';
-import walk from 'ignore-walk';
-import { validateTemplatePath } from '../src/server/conf.js';
-import dotenv from 'dotenv';
-
-const logger = loggerFactory(import.meta);
-
-dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
-
-logger.info('argv', process.argv);
-
-let [exe, dir, type] = process.argv;
-let rawPath = process.argv[3].replaceAll(`'`, '');
-let toPath = process.argv[4].replaceAll(`'`, '');
-let path = `${rawPath}`.split('/');
-path.pop();
-path = path.join('/');
-const file = `${rawPath}`.split('/').pop();
-const ext = file.split('.')[1];
-let name = getCapVariableName(file.split('.')[0]);
-let content = '';
-
-logger.info('File metadata', { path, file, ext, name });
-
-try {
-  switch (type) {
-    case 'update-template':
-    case 'copy-src':
-      console.log({ rawPath, toPath });
-
-      let result = await new Promise((resolve) =>
-        walk(
-          {
-            path: rawPath, // root dir to start in. defaults to process.cwd()
-            ignoreFiles: [`.gitignore`], // list of filenames. defaults to ['.ignore']
-            includeEmpty: false, // true to include empty dirs, default false
-            follow: false, // true to follow symlink dirs, default false
-          },
-          (...args) => resolve(args[1]),
-        ),
-      );
-
-      result = result.filter((path) => !path.startsWith('.git'));
-
-      console.log('copy paths', result);
-
-      if (type === 'update-template') {
-        if (!fs.existsSync(toPath))
-          shellExec(`cd .. && underpost clone ${process.env.GITHUB_USERNAME}/pwa-microservices-template`);
-        else {
-          shellExec(`cd ${toPath} && git reset && git checkout . && git clean -f -d`);
-          shellExec(`underpost pull ${toPath} ${process.env.GITHUB_USERNAME}/pwa-microservices-template`);
-          shellExec(`sudo rm -rf ${toPath}/engine-private`);
-          shellExec(`sudo rm -rf ${toPath}/logs`);
-        }
-      } else {
-        fs.removeSync(toPath);
-      }
-
-      for (const copyPath of result) {
-        if (copyPath === 'NaN') continue;
-        const folder = getDirname(`${toPath}/${copyPath}`);
-        const absolutePath = `${rawPath}/${copyPath}`;
-
-        if (type === 'update-template' && !validateTemplatePath(absolutePath)) continue;
-
-        if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
-
-        logger.info('build', `${toPath}/${copyPath}`);
-
-        fs.copyFileSync(absolutePath, `${toPath}/${copyPath}`);
-      }
-
-      if (type === 'update-template') {
-        fs.copySync(`./.vscode`, `../pwa-microservices-template/.vscode`);
-        // fs.copySync(`./.github`, `../pwa-microservices-template/.github`);
-        fs.copySync(`./src/client/public/default`, `../pwa-microservices-template/src/client/public/default`);
-
-        for (const checkoutPath of ['README.md', 'package.json'])
-          shellExec(`cd ../pwa-microservices-template && git checkout ${checkoutPath}`);
-
-        for (const deletePath of [
-          './.github',
-          './manifests/deployment/dd-lampp-development',
-          './manifests/deployment/dd-cyberia-development',
-          './manifests/deployment/dd-core-development',
-          './manifests/deployment/dd-template-development',
-          './src/server/object-layer.js',
-          './src/server/atlas-sprite-sheet-generator.js',
-          './src/server/shape-generator.js',
-          './src/server/semantic-layer-generator.js',
-          './src/server/semantic-layer-generator-floor.js',
-          './src/server/semantic-layer-generator-skin.js',
-          './src/server/semantic-layer-generator-resource.js',
-          './src/server/besu-genesis-generator.js',
-          './src/grpc/cyberia',
-          './src/runtime/cyberia-server',
-          './src/runtime/cyberia-client',
-          './test/shape-generator.test.js',
-          './src/client/public/cyberia-docs',
-          'bin/cyberia.js',
-        ]) {
-          if (fs.existsSync(deletePath)) fs.removeSync('../pwa-microservices-template/' + deletePath);
-        }
-
-        fs.mkdirSync(`../pwa-microservices-template/.github/workflows`, {
-          recursive: true,
-        });
-        for (const _path of [
-          `./.github/workflows/pwa-microservices-template-page.cd.yml`,
-          `./.github/workflows/pwa-microservices-template-test.ci.yml`,
-          `./.github/workflows/npmpkg.ci.yml`,
-          `./.github/workflows/ghpkg.ci.yml`,
-          `./.github/workflows/gitlab.ci.yml`,
-          `./.github/workflows/publish.ci.yml`,
-          `./.github/workflows/release.cd.yml`,
-          `./src/client/services/user/guest.service.js`,
-          './src/api/user/guest.service.js',
-          './src/ws/IoInterface.js',
-          './src/ws/IoServer.js',
-        ])
-          fs.copyFileSync(_path, `../pwa-microservices-template/${_path}`);
-
-        const originPackageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
-        const templatePackageJson = JSON.parse(fs.readFileSync('../pwa-microservices-template/package.json', 'utf8'));
-
-        const name = templatePackageJson.name;
-        const description = templatePackageJson.description;
-        const dev = templatePackageJson.scripts.dev;
-        const build = templatePackageJson.scripts.build;
-
-        templatePackageJson.dependencies = originPackageJson.dependencies;
-        templatePackageJson.devDependencies = originPackageJson.devDependencies;
-        templatePackageJson.version = originPackageJson.version;
-        templatePackageJson.scripts = originPackageJson.scripts;
-        templatePackageJson.overrides = originPackageJson.overrides;
-        templatePackageJson.name = name;
-        templatePackageJson.description = description;
-        // templatePackageJson.scripts.dev = dev;
-        // templatePackageJson.scripts.build = build;
-        templatePackageJson.keywords = uniqueArray(
-          ['pwa', 'microservices', 'template', 'builder'].concat(templatePackageJson.keywords),
-        );
-        delete templatePackageJson.scripts['update:template'];
-        fs.writeFileSync(
-          '../pwa-microservices-template/package.json',
-          JSON.stringify(templatePackageJson, null, 4),
-          'utf8',
-        );
-        const originPackageLockJson = JSON.parse(fs.readFileSync('./package-lock.json', 'utf8'));
-
-        const templatePackageLockJson = JSON.parse(
-          fs.readFileSync('../pwa-microservices-template/package-lock.json', 'utf8'),
-        );
-
-        const originBasePackageLock = newInstance(templatePackageLockJson.packages['']);
-        templatePackageLockJson.name = name;
-        templatePackageLockJson.version = originPackageLockJson.version;
-        templatePackageLockJson.packages = originPackageLockJson.packages;
-        templatePackageLockJson.packages[''].name = name;
-        templatePackageLockJson.packages[''].version = originPackageLockJson.version;
-        templatePackageLockJson.packages[''].hasInstallScript = originBasePackageLock.hasInstallScript;
-        templatePackageLockJson.packages[''].license = originBasePackageLock.license;
-        fs.writeFileSync(
-          '../pwa-microservices-template/package-lock.json',
-          JSON.stringify(templatePackageLockJson, null, 4),
-          'utf8',
-        );
-        // Regenerate package-lock.json to match the modified package.json
-        // shellExec(`cd ../pwa-microservices-template && npm install --package-lock-only --ignore-scripts`);
-        fs.writeFileSync(
-          '../pwa-microservices-template/README.md',
-          fs
-            .readFileSync('./README.md', 'utf8')
-            .replace('<!-- template-title -->', '#### Base template for pwa/api-rest projects.'),
-          'utf8',
-        );
-      }
-
-      break;
-    case 'create':
-      const buildPath = `${path}/${name}${ext ? `.${ext}` : ''}`;
-      logger.info('Build path', buildPath);
-      fs.mkdirSync(path, { recursive: true });
-      fs.writeFileSync(buildPath, content, 'utf8');
-    default:
-      logger.error('not found operator');
-      break;
-  }
-} catch (error) {
-  logger.error(error, error.stack);
-}

package/bin/vs.js

@@ -1,74 +0,0 @@
-import fs from 'fs-extra';
-import { shellExec } from '../src/server/process.js';
-import { loggerFactory } from '../src/server/logger.js';
-
-const logger = loggerFactory(import.meta);
-
-const vsCodeRootPath = '/root/.vscode-root';
-const vsConfigRootPath = '/root/.config/Code';
-
-const vsProgram = 'code';
-
-switch (process.argv[2]) {
-  case 'info': {
-    logger.info('Formatted', 'Ctrl shift I');
-    logger.info('Command', 'Ctrl shift P');
-    logger.info('Search', 'Ctrl shift F');
-    logger.info('Debug', 'Ctrl shift D');
-    logger.info('New File', 'Ctrl N');
-    logger.info('Change tab', 'Ctrl Tab');
-    logger.info('Fold All', 'Ctrl K + Ctrl 0');
-    logger.info('Unfold All', 'Ctrl K + Ctrl J');
-    logger.info('Close All tabs', 'Ctrl K + W');
-    logger.info('Go to line number', 'Ctrl G');
-    logger.info('Change current project folder', 'Ctrl K + Ctrl O');
-    logger.info('Open new vs windows', 'Ctrl Shift N');
-    logger.info('Close current vs windows', 'Ctrl Shift W');
-    logger.info('Preview md', 'Ctrl shift V');
-    logger.info('Open git changes', 'Ctrl G + G');
-    logger.warn('Terminal shortcut configure with command pallette', 'Ctl shift T');
-    break;
-  }
-  case 'import':
-    {
-      const extensions = JSON.parse(fs.readFileSync(`./.vscode/extensions.json`, 'utf8'));
-      extensions.recommendations.map((extension) => {
-        if (extension)
-          shellExec(
-            `sudo ${vsProgram} --user-data-dir="${vsCodeRootPath}" --no-sandbox --install-extension ${extension}`,
-          );
-      });
-    }
-    break;
-  case 'export':
-    {
-      shellExec(
-        `sudo ${vsProgram} --user-data-dir="${vsCodeRootPath}" --no-sandbox --list-extensions > vs-extensions.txt`,
-      );
-      fs.writeFileSync(
-        `./.vscode/extensions.json`,
-        JSON.stringify(
-          {
-            recommendations: fs
-              .readFileSync(`./vs-extensions.txt`, 'utf8')
-              .split(`\n`)
-              .filter((ext) => ext.trim()),
-          },
-          null,
-          4,
-        ),
-        'utf8',
-      );
-      fs.removeSync(`./vs-extensions.txt`);
-    }
-    break;
-
-  case 'clean': {
-    shellExec(`sudo rm -rf ${vsCodeRootPath}/*`);
-    shellExec(`sudo rm -rf ${vsConfigRootPath}`);
-    break;
-  }
-  default:
-    shellExec(`sudo ${vsProgram} ${process.argv[2]} --user-data-dir="${vsCodeRootPath}" --no-sandbox`);
-    break;
-}

package/bin/zed.js

@@ -1,84 +0,0 @@
-import { shellExec } from '../src/server/process.js';
-import fs from 'fs-extra';
-import { loggerFactory } from '../src/server/logger.js';
-import { getUnderpostRootPath } from '../src/server/conf.js';
-
-const logger = loggerFactory(import.meta);
-const underpostRoot = getUnderpostRootPath();
-
-const settings = {
-  ui_font_size: 16,
-  buffer_font_size: 15,
-  theme: {
-    mode: 'system',
-    light: 'One Dark',
-    dark: 'One Dark',
-  },
-
-  features: {
-    edit_prediction_provider: 'copilot',
-    copilot: true,
-  },
-
-  show_edit_predictions: true,
-
-  edit_predictions: {
-    mode: 'eager',
-  },
-};
-
-const keyMap = [
-  {
-    context: 'Editor',
-    bindings: {
-      'ctrl-c': 'editor::Copy',
-      'ctrl-x': 'editor::Cut',
-      'ctrl-v': 'editor::Paste',
-      'ctrl-shift-c': 'editor::CopyAndTrim',
-      'ctrl-shift-v': 'editor::Paste',
-      'cmd-c': 'editor::Copy',
-      'cmd-x': 'editor::Cut',
-      'cmd-v': 'editor::Paste',
-    },
-  },
-  {
-    context: 'Terminal',
-    bindings: {
-      'ctrl-shift-c': 'terminal::Copy',
-      'ctrl-shift-v': 'terminal::Paste',
-      'cmd-shift-c': 'terminal::Copy',
-      'cmd-shift-v': 'terminal::Paste',
-    },
-  },
-  {
-    context: 'Editor && edit_prediction',
-    bindings: {
-      tab: 'editor::AcceptEditPrediction',
-      'alt-tab': 'editor::AcceptEditPrediction',
-      'alt-l': null,
-    },
-  },
-  {
-    context: 'Editor && edit_prediction_conflict',
-    bindings: {
-      'alt-l': 'editor::AcceptEditPrediction',
-      tab: 'editor::ComposeCompletion',
-    },
-  },
-];
-
-if (!fs.existsSync('/root/.config/zed')) fs.mkdirSync('/root/.config/zed', { recursive: true });
-fs.writeFileSync(`/root/.config/zed/settings.json`, JSON.stringify(settings, null, 4), 'utf8');
-fs.writeFileSync(`/root/.config/zed/keymap.json`, JSON.stringify(keyMap, null, 4), 'utf8');
-
-shellExec(`ZED_ALLOW_ROOT=true zed ${process.argv[2] ? process.argv[2] : '.'}`);
-
-logger.info('Connect copilot device', 'https://github.com/login/device');
-logger.info('Comments', 'Ctrl shift 7');
-logger.info('Unfold', 'Ctrl K + Ctrl J');
-logger.info('Fold', 'Ctrl K + Ctrl 0');
-logger.info('Command Palette', 'Ctrl Shift P');
-logger.info('Open File', 'Ctrl P');
-logger.info('Find in Files', 'Ctrl Shift F');
-logger.info('Go to Line', 'Ctrl G');
-logger.info('New file', 'Ctrl N');