hologit 0.43.2 → 0.44.0

package/index.d.ts

@@ -1,3 +1,9 @@
+declare module 'git-client' {
+    export class Git {
+        constructor(options: { gitDir: string; workTree?: string });
+    }
+}
+
 declare module 'hologit' {
     import { Git as GitClient } from 'git-client';
     import { Docker } from 'dockerode';
@@ -60,15 +66,15 @@ declare module 'hologit' {
     }
 
     export class Git {
-        static async get(): Promise<typeof GitClient>;
+        static get(): Promise<typeof GitClient>;
         constructor(options: GitOptions);
         gitDir: string;
         workTree?: string;
     }
 
     export class BlobObject {
-        static async write(repo: Repo, content: string): Promise<BlobObject>;
-        static async writeFromFile(repo: Repo, filePath: string): Promise<BlobObject>;
+        static write(repo: Repo, content: string): Promise<BlobObject>;
+        static writeFromFile(repo: Repo, filePath: string): Promise<BlobObject>;
 
         constructor(repo: Repo, options: GitObjectOptions);
 
@@ -78,12 +84,12 @@ declare module 'hologit' {
         isBlob: boolean;
         type: 'blob';
 
-        async read(): Promise<string>;
+        read(): Promise<string>;
     }
 
     export class TreeObject {
         static getEmptyTreeHash(): string;
-        static async createFromRef(repo: Repo, ref: string): Promise<TreeObject>;
+        static createFromRef(repo: Repo, ref: string): Promise<TreeObject>;
 
         constructor(repo: Repo, options?: { hash?: string; parent?: TreeObject | null });
 
@@ -95,19 +101,19 @@ declare module 'hologit' {
         type: 'tree';
         mode: '040000';
 
-        async getHash(): Promise<string>;
+        getHash(): Promise<string>;
         getWrittenHash(): string | null;
         markDirty(): void;
-        async getChild(childPath: string): Promise<TreeObject | BlobObject | CommitObject | null>;
-        async writeChild(childPath: string, content: string | BlobObject): Promise<BlobObject>;
-        async getChildren(): Promise<{ [key: string]: TreeObject | BlobObject | CommitObject }>;
-        async getBlobMap(): Promise<{ [key: string]: BlobObject }>;
-        async deleteChild(childPath: string): Promise<void>;
-        async getSubtree(subtreePath: string, create?: boolean): Promise<TreeObject | null>;
-        async getSubtreeStack(subtreePath: string, create?: boolean): Promise<TreeObject[] | null>;
-        async write(): Promise<string>;
-        async merge(input: TreeObject, options?: MergeOptions, basePath?: string, preloadChildren?: boolean): Promise<void>;
-        async clone(): Promise<TreeObject>;
+        getChild(childPath: string): Promise<TreeObject | BlobObject | CommitObject | null>;
+        writeChild(childPath: string, content: string | BlobObject): Promise<BlobObject>;
+        getChildren(): Promise<{ [key: string]: TreeObject | BlobObject | CommitObject }>;
+        getBlobMap(): Promise<{ [key: string]: BlobObject }>;
+        deleteChild(childPath: string): Promise<void>;
+        getSubtree(subtreePath: string, create?: boolean): Promise<TreeObject | null>;
+        getSubtreeStack(subtreePath: string, create?: boolean): Promise<TreeObject[] | null>;
+        write(): Promise<string>;
+        merge(input: TreeObject, options?: MergeOptions, basePath?: string, preloadChildren?: boolean): Promise<void>;
+        clone(): Promise<TreeObject>;
     }
 
     export class CommitObject {
@@ -128,10 +134,10 @@ declare module 'hologit' {
 
         getWorkspace(): Workspace;
         getRepo(): Repo;
-        async readConfig(): Promise<any>;
-        async writeConfig(config?: any): Promise<void>;
-        async getConfig(): Promise<any>;
-        async getCachedConfig(): Promise<any>;
+        readConfig(): Promise<any>;
+        writeConfig(config?: any): Promise<void>;
+        getConfig(): Promise<any>;
+        getCachedConfig(): Promise<any>;
     }
 
     export class Branch extends Configurable {
@@ -141,17 +147,17 @@ declare module 'hologit' {
 
         getKind(): 'holobranch';
         getConfigPath(): string;
-        async isDefined(): Promise<boolean>;
+        isDefined(): Promise<boolean>;
         getMapping(key: string): Mapping;
-        async getMappings(): Promise<Map<string, Mapping>>;
-        async composite(options: {
+        getMappings(): Promise<Map<string, Mapping>>;
+        composite(options: {
             outputTree?: TreeObject;
             fetch?: boolean | string[];
             cacheFrom?: string | null;
             cacheTo?: string | null;
         }): Promise<TreeObject>;
         getLens(name: string): Lens;
-        async getLenses(): Promise<Map<string, Lens>>;
+        getLenses(): Promise<Map<string, Lens>>;
     }
 
     export class Source extends Configurable {
@@ -163,21 +169,21 @@ declare module 'hologit' {
 
         getKind(): 'holosource';
         getConfigPath(): string;
-        async getSpec(): Promise<{ hash: string; ref: string; data: any }>;
-        async getCachedSpec(): Promise<{ hash: string; ref: string; data: any }>;
-        async queryRef(): Promise<{ hash: string; ref: string } | null>;
-        async hashWorkTree(): Promise<string | null>;
-        async getOutputTree(options?: {
+        getSpec(): Promise<{ hash: string; ref: string; data: any }>;
+        getCachedSpec(): Promise<{ hash: string; ref: string; data: any }>;
+        queryRef(): Promise<{ hash: string; ref: string } | null>;
+        hashWorkTree(): Promise<string | null>;
+        getOutputTree(options?: {
             working?: boolean | null;
             fetch?: boolean | string[];
             cacheFrom?: string | null;
             cacheTo?: string | null;
         }): Promise<string>;
-        async getHead(options?: { required?: boolean; working?: boolean | null }): Promise<string | null>;
-        async getCachedHead(): Promise<string | null>;
-        async getBranch(): Promise<string | null>;
-        async fetch(options?: { depth?: number; unshallow?: boolean | null }, ...refs: string[]): Promise<{ refs: string[] }>;
-        async checkout(options?: { submodule?: boolean }): Promise<{
+        getHead(options?: { required?: boolean; working?: boolean | null }): Promise<string | null>;
+        getCachedHead(): Promise<string | null>;
+        getBranch(): Promise<string | null>;
+        fetch(options?: { depth?: number; unshallow?: boolean | null }, ...refs: string[]): Promise<{ refs: string[] }>;
+        checkout(options?: { submodule?: boolean }): Promise<{
             path: string;
             head: string;
             branch: string | null;
@@ -195,13 +201,13 @@ declare module 'hologit' {
 
         getKind(): 'hololens';
         getConfigPath(): string;
-        async buildInputTree(inputRoot?: TreeObject): Promise<TreeObject>;
-        async buildSpec(inputTree: TreeObject): Promise<{
+        buildInputTree(inputRoot?: TreeObject): Promise<TreeObject>;
+        buildSpec(inputTree: TreeObject): Promise<{
             hash: string;
             ref: string;
             data: any;
         }>;
-        async executeSpec(specHash: string, options: {
+        executeSpec(specHash: string, options: {
             refresh?: boolean;
             save?: boolean;
             repo?: Repo | null;
@@ -209,7 +215,7 @@ declare module 'hologit' {
             cacheTo?: string | null;
         }): Promise<string>;
 
-        static async executeSpec(specHash: string, options: {
+        static executeSpec(specHash: string, options: {
             refresh?: boolean;
             save?: boolean;
             repo?: Repo | null;
@@ -226,18 +232,18 @@ declare module 'hologit' {
         getWorkspace(): Workspace;
         getKind(): 'holospace';
         getConfigPath(): string;
-        async writeWorkingChanges(): Promise<void>;
+        writeWorkingChanges(): Promise<void>;
         getBranch(name: string): Branch;
-        async getBranches(): Promise<Map<string, Branch>>;
+        getBranches(): Promise<Map<string, Branch>>;
         getSource(name: string): Source;
-        async getSources(): Promise<Map<string, Source>>;
-        async getLayers(): Promise<Map<string, Map<string, Mapping>>>;
+        getSources(): Promise<Map<string, Source>>;
+        getLayers(): Promise<Map<string, Map<string, Mapping>>>;
         getLens(name: string): Lens;
-        async getLenses(): Promise<Map<string, Lens>>;
+        getLenses(): Promise<Map<string, Lens>>;
     }
 
     export class Repo {
-        static async getFromEnvironment(options?: { ref?: string; working?: boolean }): Promise<Repo>;
+        static getFromEnvironment(options?: { ref?: string; working?: boolean }): Promise<Repo>;
 
         constructor(options: RepoOptions);
 
@@ -245,27 +251,27 @@ declare module 'hologit' {
         ref: string;
         workTree: string | null;
 
-        async getWorkspace(): Promise<Workspace>;
-        async createWorkspaceFromRef(ref: string): Promise<Workspace>;
-        async createWorkspaceFromTreeHash(hash: string): Promise<Workspace>;
-        async getGit(): Promise<GitClient>;
-        async resolveRef(ref?: string | null): Promise<string | null>;
+        getWorkspace(): Promise<Workspace>;
+        createWorkspaceFromRef(ref: string): Promise<Workspace>;
+        createWorkspaceFromTreeHash(hash: string): Promise<Workspace>;
+        getGit(): Promise<GitClient>;
+        resolveRef(ref?: string | null): Promise<string | null>;
         createBlob(options: GitObjectOptions): BlobObject;
-        async writeBlob(content: string): Promise<BlobObject>;
-        async writeBlobFromFile(filePath: string): Promise<BlobObject>;
+        writeBlob(content: string): Promise<BlobObject>;
+        writeBlobFromFile(filePath: string): Promise<BlobObject>;
         createTree(options?: { hash?: string; parent?: TreeObject | null }): TreeObject;
-        async createTreeFromRef(ref: string): Promise<TreeObject>;
+        createTreeFromRef(ref: string): Promise<TreeObject>;
         createCommit(options: GitObjectOptions): CommitObject;
-        async hasCommit(commit: string): Promise<boolean>;
-        async hashWorkTree(): Promise<string>;
-        async watch(options: { callback: (treeHash: string, commitHash?: string) => void }): Promise<{
+        hasCommit(commit: string): Promise<boolean>;
+        hashWorkTree(): Promise<string>;
+        watch(options: { callback: (treeHash: string, commitHash?: string) => void }): Promise<{
             watching: Promise<void>;
             cancel: () => void;
         }>;
     }
 
     export class Projection {
-        static async projectBranch(branch: Branch, options?: ProjectionOptions): Promise<string>;
+        static projectBranch(branch: Branch, options?: ProjectionOptions): Promise<string>;
 
         constructor(options: { branch: Branch });
 
@@ -273,27 +279,27 @@ declare module 'hologit' {
         workspace: Workspace;
         output: Workspace;
 
-        async composite(options: {
+        composite(options: {
             fetch?: boolean | string[];
             cacheFrom?: string | null;
             cacheTo?: string | null;
         }): Promise<void>;
-        async lens(options: {
+        lens(options: {
             cacheFrom?: string | null;
             cacheTo?: string | null;
         }): Promise<void>;
-        async commit(ref: string, options?: {
+        commit(ref: string, options?: {
             parentCommit?: string | null;
             commitMessage?: string | null;
         }): Promise<string>;
     }
 
     export class Studio {
-        static async cleanup(): Promise<void>;
-        static async getHab(): Promise<any>;
-        static async getDocker(): Promise<Docker>;
-        static async isEnvironmentStudio(): Promise<boolean>;
-        static async get(gitDir: string): Promise<Studio>;
+        static cleanup(): Promise<void>;
+        static getHab(): Promise<any>;
+        static getDocker(): Promise<Docker>;
+        static isEnvironmentStudio(): Promise<boolean>;
+        static get(gitDir: string): Promise<Studio>;
 
         constructor(options: { gitDir: string; container: any });
 
@@ -301,11 +307,11 @@ declare module 'hologit' {
         gitDir: string;
 
         isLocal(): boolean;
-        async habExec(...command: any[]): Promise<string>;
-        async habPkgExec(pkg: string, bin: string, ...args: any[]): Promise<string>;
-        async holoExec(...command: any[]): Promise<string>;
-        async holoLensExec(spec: string): Promise<string>;
-        async getPackage(query: string, options?: { install?: boolean }): Promise<string | null>;
+        habExec(...command: any[]): Promise<string>;
+        habPkgExec(pkg: string, bin: string, ...args: any[]): Promise<string>;
+        holoExec(...command: any[]): Promise<string>;
+        holoLensExec(spec: string): Promise<string>;
+        getPackage(query: string, options?: { install?: boolean }): Promise<string | null>;
     }
 
     export class Mapping extends Configurable {
@@ -319,13 +325,17 @@ declare module 'hologit' {
         getConfigPath(): string;
     }
 
-    export class SpecObject extends BlobObject {
-        static async write(repo: Repo, kind: string, data: any): Promise<{
+    export class SpecObject {
+        constructor(repo: Repo, options: GitObjectOptions);
+
+        repo: Repo;
+        hash: string;
+        isSpec: boolean;
+
+        static write(repo: Repo, kind: string, data: any): Promise<{
             hash: string;
             ref: string;
         }>;
         static buildRef(kind: string, hash: string): string;
-
-        isSpec: boolean;
     }
 }

package/lib/Studio.js

@@ -1,16 +1,54 @@
+const { spawn } = require('child_process');
 const stream = require('stream');
-const Docker = require('dockerode');
 const os = require('os');
 const exitHook = require('async-exit-hook');
 const fs = require('mz/fs');
 
-
 const logger = require('./logger');
 
-
 const studioCache = new Map();
-let hab, docker;
+let hab;
+
+/**
+ * Helper function to execute a Docker CLI command.
+ * @param {Array<string>} args - The arguments to pass to the docker command.
+ * @param {Object} options - Options for child_process.spawn.
+ * @returns {Promise<string>} - Resolves with stdout data.
+ */
+function execDocker(args, options = { $relayStderr: false, $relayStdout: false }) {
+    logger.debug(`docker ${args.join(' ')}`);
+
+    return new Promise((resolve, reject) => {
+        const dockerProcess = spawn('docker', args, { stdio: 'pipe', ...options });
+
+        if (options.$relayStderr !== false) {
+            dockerProcess.stderr.pipe(process.stderr);
+        }
+
+        if (options.$relayStdout !== false) {
+            dockerProcess.stdout.pipe(process.stdout);
+        }
+
+        let stdout = '';
+        let stderr = '';
+
+        dockerProcess.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        dockerProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
 
+        dockerProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            } else {
+                reject(new Error(stderr.trim()));
+            }
+        });
+    });
+}
 
 /**
  * A studio session that can be used to run multiple commands, using chroot if available or docker container
@@ -23,11 +61,15 @@ class Studio {
         for (const [gitDir, studio] of studioCache) {
             const { container } = studio;
 
-            if (container && container.type != 'studio') {
+            if (container && container.type !== 'studio') {
                 logger.info(`terminating studio container: ${container.id}`);
-                await container.stop();
-                await container.remove();
-                cleanupCount++;
+                try {
+                    await execDocker(['stop', container.id]);
+                    await execDocker(['rm', container.id]);
+                    cleanupCount++;
+                } catch (err) {
+                    logger.error(`Failed to stop/remove container ${container.id}: ${err.message}`);
+                }
             }
 
             studioCache.delete(gitDir);
@@ -46,19 +88,6 @@ class Studio {
         return hab;
     }
 
-    static async getDocker () {
-        if (!docker) {
-            const { DOCKER_HOST: dockerHost } = process.env;
-            const dockerHostMatch = dockerHost && dockerHost.match(/^unix:\/\/(\/.*)$/);
-            const socketPath = dockerHostMatch ? dockerHostMatch[1] : '/var/run/docker.sock';
-
-            docker = new Docker({ socketPath });
-            logger.info(`connected to docker on: ${socketPath}`);
-        }
-
-        return docker;
-    }
-
     static async isEnvironmentStudio () {
         return Boolean(process.env.STUDIO_TYPE);
     }
@@ -91,39 +120,9 @@ class Studio {
         }
 
 
-        // connect with Docker API
-        const docker = await Studio.getDocker();
-
-
         // pull latest studio container
         try {
-            await new Promise((resolve, reject) => {
-                docker.pull('jarvus/hologit-studio:latest', (streamErr, stream) => {
-                    if (streamErr) {
-                        reject(streamErr);
-                        return;
-                    }
-
-                    let lastStatus;
-
-                    docker.modem.followProgress(
-                        stream,
-                        (err, output) => {
-                            if (err) {
-                                reject(err);
-                            } else {
-                                resolve(output);
-                            }
-                        },
-                        event => {
-                            if (event.status != lastStatus) {
-                                logger.info(`docker pull: ${event.status}`);
-                                lastStatus = event.status;
-                            }
-                        }
-                    );
-                });
-            });
+            await execDocker(['pull', 'jarvus/hologit-studio:latest'], { $relayStdout: true, $relayStderr: true });
         } catch (err) {
             logger.error(`failed to pull studio image via docker: ${err.message}`);
         }
@@ -157,65 +156,70 @@ class Studio {
         }
 
 
-        // start studio container
-        let container;
+        // create studio container
+        let containerId;
+        let defaultUser;
         try {
-            container = await docker.createContainer({
-                Image: 'jarvus/hologit-studio',
-                Labels: {
-                    'sh.holo.studio': 'yes'
-                },
-                AttachStdin: false,
-                AttachStdout: true,
-                AttachStderr: true,
-                Env: [
-                    'STUDIO_TYPE=holo',
-                    'GIT_DIR=/git',
-                    'GIT_WORK_TREE=/hab/cache',
-                    `DEBUG=${process.env.DEBUG||''}`,
-                    `HAB_LICENSE=accept-no-persist`
-                ],
-                WorkingDir: '/git',
-                Volumes: volumesConfig,
-                HostConfig: {
-                    Binds: bindsConfig,
-                    // ExposedPorts: {
-                    //     "9229/tcp": { }
-                    // },
-                    // PortBindings: {
-                    //     '9229/tcp': [
-                    //         {
-                    //             HostIp: '0.0.0.0',
-                    //             HostPort: '9229'
-                    //         }
-                    //     ]
-                    // }
-                }
-            });
+            // Prepare environment variables
+            const envArgs = [
+                '--env', 'STUDIO_TYPE=holo',
+                '--env', 'GIT_DIR=/git',
+                '--env', 'GIT_WORK_TREE=/hab/cache',
+                '--env', `DEBUG=${process.env.DEBUG || ''}`,
+                '--env', 'HAB_LICENSE=accept-no-persist'
+            ];
+
+            // Prepare volume bindings
+            const volumeArgs = [];
+            for (const bind of bindsConfig) {
+                volumeArgs.push('-v', bind);
+            }
+
+            // Create container
+            const createArgs = [
+                'create',
+                '--label', 'sh.holo.studio=yes',
+                '--workdir', '/git',
+                ...envArgs,
+                ...volumeArgs,
+                'jarvus/hologit-studio:latest'
+            ];
+
+            containerId = await execDocker(createArgs);
+            containerId = containerId.split('\n').pop().trim(); // Get the container ID from output
 
             logger.info('starting studio container');
-            await container.start();
+            await execDocker(['start', containerId]);
 
             const { uid, gid, username } = os.userInfo();
 
             if (uid && gid && username) {
                 logger.info(`configuring container to use user: ${username}`);
-                await containerExec(container, 'adduser', '-u', `${uid}`, '-G', 'developer', '-D', username);
-                await containerExec(container, 'mkdir', '-p', `/home/${username}/.hab`);
-                await containerExec(container, 'ln', '-sf', '/hab/cache', `/home/${username}/.hab/`);
-                container.defaultUser = `${uid}`;
+                await containerExec({ id: containerId }, 'adduser', '-u', `${uid}`, '-G', 'developer', '-D', username);
+                await containerExec({ id: containerId }, 'mkdir', '-p', `/home/${username}/.hab`);
+                await containerExec({ id: containerId }, 'ln', '-sf', '/hab/cache', `/home/${username}/.hab/`);
+                if (!artifactCachePath) await containerExec({ id: containerId }, 'chown', '-R', `${uid}:${gid}`, '/hab/cache');
+                defaultUser = `${uid}`;
             }
 
-            const studio = new Studio({ gitDir, container });
+            const studio = new Studio({ gitDir, container: { id: containerId, defaultUser } });
             studioCache.set(gitDir, studio);
             return studio;
 
         } catch (err) {
-            logger.error('container failed: %o', err);
+            logger.error(`container failed: ${err.message}`);
 
-            if (container) {
-                await container.stop();
-                await container.remove();
+            if (containerId) {
+                try {
+                    await execDocker(['stop', containerId]);
+                } catch (stopErr) {
+                    logger.error(`Failed to stop container ${containerId}: ${stopErr.message}`);
+                }
+                try {
+                    await execDocker(['rm', containerId]);
+                } catch (rmErr) {
+                    logger.error(`Failed to remove container ${containerId}: ${rmErr.message}`);
+                }
             }
         }
     }
@@ -227,14 +231,14 @@ class Studio {
     }
 
     isLocal () {
-        return this.container.type == 'studio';
+        return this.container.type === 'studio';
     }
 
     /**
      * Run a command in the studio
      */
     async habExec (...command) {
-        const options = typeof command[command.length-1] == 'object'
+        const options = typeof command[command.length-1] === 'object'
             ? command.pop()
             : {};
 
@@ -274,7 +278,7 @@ class Studio {
         //         $env: { PATH }
         //     }
         // );
-        if (logger.level == 'debug') {
+        if (logger.level === 'debug') {
             command.unshift('--debug');
         }
 
@@ -286,55 +290,66 @@ class Studio {
     }
 
     async getPackage (query, { install } = { install: false }) {
-        let packagePath = await this.habExec('pkg', 'path', query, { $nullOnError: true, $relayStderr: false });
+        let packagePath;
+        try {
+            packagePath = await this.habExec('pkg', 'path', query, { $nullOnError: true, $relayStderr: false });
+        } catch (err) {
+            packagePath = null;
+        }
 
         if (!packagePath && install) {
             await this.habExec('pkg', 'install', query);
-            packagePath = await this.habExec('pkg', 'path', query);
+            try {
+                packagePath = await this.habExec('pkg', 'path', query);
+            } catch (err) {
+                packagePath = null;
+            }
         }
 
         return packagePath ? packagePath.substr(10) : null;
     }
 }
 
-
 exitHook(callback => Studio.cleanup().then(callback));
 
-
+/**
+ * Executes a command inside the specified Docker container.
+ * @param {Object} container - The container object containing at least the `id` and optionally `defaultUser`.
+ * @param  {...string} command - The command and its arguments to execute.
+ * @returns {Promise<string>} - Resolves with the command's stdout output.
+ */
 async function containerExec (container, ...command) {
-    const options = typeof command[command.length-1] == 'object'
+    const options = typeof command[command.length-1] === 'object'
         ? command.pop()
         : {};
 
     logger.info(`studio-exec: ${command.join(' ')}`);
 
-    const env = [];
+    const execArgs = ['exec'];
+
+    if (options.$user) {
+        execArgs.push('--user', options.$user);
+    } else if (container.defaultUser) {
+        execArgs.push('--user', container.defaultUser);
+    }
+
     if (options.$env) {
-        for (const key of Object.keys(options.$env)) {
-            env.push(`${key}=${options.$env[key]}`);
+        for (const [key, value] of Object.entries(options.$env)) {
+            execArgs.push('--env', `${key}=${value}`);
         }
     }
 
-    const exec = await container.exec({
-        Cmd: command,
-        AttachStdout: true,
-        AttachStderr: options.$relayStderr !== false,
-        Env: env,
-        User: `${container.defaultUser || options.$user || ''}`
-    });
-
-    const execStream = await exec.start();
+    execArgs.push(container.id, ...command);
 
-    return new Promise((resolve, reject) => {
-        const output = [];
-        const outputStream = new stream.PassThrough();
-
-        outputStream.on('data', chunk => output.push(chunk.toString('utf8')));
-        execStream.on('end', () => resolve(output.join('').trim()));
-
-        container.modem.demuxStream(execStream, outputStream, process.stderr);
-    });
+    try {
+        const output = await execDocker(execArgs, { $relayStdout: true, $relayStderr: true });
+        return output;
+    } catch (err) {
+        if (options.$nullOnError) {
+            return null;
+        }
+        throw err;
+    }
 }
 
-
 module.exports = Studio;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hologit",
-  "version": "0.43.2",
+  "version": "0.44.0",
   "description": "Hologit automates the projection of layered composite file trees based on flat, declarative plans",
   "repository": "https://github.com/EmergencePlatform/hologit",
   "main": "lib/index.js",
@@ -12,9 +12,8 @@
     "@iarna/toml": "^2.2.5",
     "async-exit-hook": "^2.0.1",
     "axios": "^1.7.7",
-    "chokidar": "^3.5.3",
+    "chokidar": "^4.0.1",
     "debounce": "^2.0.0",
-    "dockerode": "^4.0.2",
     "fb-watchman": "^2.0.1",
     "git-client": "^1.8.3",
     "hab-client": "^1.1.3",