@hexabot-ai/cli 3.6.0-beta.0 → 3.7.0-beta.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/commands/dev.js +18 -42
- package/dist/commands/start.js +20 -44
- package/dist/commands/stop.js +7 -19
- package/dist/core/compose.js +30 -0
- package/dist/core/config.js +1 -1
- package/dist/core/project-run.js +31 -0
- package/dist/core/project.js +0 -3
- package/package.json +3 -1
- package/src/commands/dev.ts +20 -71
- package/src/commands/start.ts +23 -76
- package/src/commands/stop.ts +7 -38
- package/src/core/compose.ts +63 -0
- package/src/core/config.ts +1 -1
- package/src/core/project-run.ts +54 -0
- package/src/core/project.ts +0 -4
package/dist/commands/dev.js
CHANGED
|
@@ -4,14 +4,11 @@
|
|
|
4
4
|
* Full terms: see LICENSE.md.
|
|
5
5
|
*/
|
|
6
6
|
import * as path from 'path';
|
|
7
|
-
import
|
|
8
|
-
import { loadProjectConfig
|
|
9
|
-
import {
|
|
10
|
-
import {
|
|
11
|
-
import {
|
|
12
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
13
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
14
|
-
import { parseServices } from '../utils/services.js';
|
|
7
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
8
|
+
import { loadProjectConfig } from '../core/config.js';
|
|
9
|
+
import { runPackageScript } from '../core/package-manager.js';
|
|
10
|
+
import { bootstrapProjectEnv, resolveProjectPackageManager, } from '../core/project-run.js';
|
|
11
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
15
12
|
export const registerDevCommand = (program) => {
|
|
16
13
|
program
|
|
17
14
|
.command('dev')
|
|
@@ -30,44 +27,23 @@ export const runDev = async (options = {}) => {
|
|
|
30
27
|
const projectRoot = path.resolve(options.cwd || process.cwd());
|
|
31
28
|
assertHexabotProject(projectRoot);
|
|
32
29
|
const config = loadProjectConfig(projectRoot);
|
|
33
|
-
const
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
updateProjectConfig(projectRoot, { packageManager: pm });
|
|
37
|
-
}
|
|
38
|
-
const shouldBootstrap = options.envBootstrap !== false;
|
|
39
|
-
if (shouldBootstrap) {
|
|
40
|
-
if (options.docker) {
|
|
41
|
-
bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
|
|
42
|
-
}
|
|
43
|
-
else {
|
|
44
|
-
const envFile = options.env || config.env.local;
|
|
45
|
-
const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
|
|
46
|
-
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
47
|
-
}
|
|
30
|
+
const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
|
|
31
|
+
if (options.envBootstrap !== false) {
|
|
32
|
+
bootstrapProjectEnv(projectRoot, config, options);
|
|
48
33
|
}
|
|
49
34
|
if (options.docker) {
|
|
50
|
-
|
|
35
|
+
const upArgs = ['up', '--build'];
|
|
36
|
+
if (options.detach) {
|
|
37
|
+
upArgs.push('-d');
|
|
38
|
+
}
|
|
39
|
+
runProjectCompose(projectRoot, config, {
|
|
40
|
+
services: options.services,
|
|
41
|
+
mode: 'dev',
|
|
42
|
+
args: upArgs,
|
|
43
|
+
action: 'Starting Docker services',
|
|
44
|
+
});
|
|
51
45
|
}
|
|
52
46
|
else {
|
|
53
47
|
runPackageScript(pm, config.devScript, projectRoot);
|
|
54
48
|
}
|
|
55
49
|
};
|
|
56
|
-
const runDockerDev = async (projectRoot, options, config) => {
|
|
57
|
-
checkDocker({ silent: true });
|
|
58
|
-
ensureDockerFolder(projectRoot);
|
|
59
|
-
const servicesInput = parseServices(options.services || '');
|
|
60
|
-
const services = servicesInput.length
|
|
61
|
-
? servicesInput
|
|
62
|
-
: config.docker.defaultServices;
|
|
63
|
-
const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
|
|
64
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
65
|
-
const composeArgs = generateComposeFiles(composeFile, services, 'dev');
|
|
66
|
-
const upArgs = ['up', '--build'];
|
|
67
|
-
if (options.detach) {
|
|
68
|
-
upArgs.push('-d');
|
|
69
|
-
}
|
|
70
|
-
const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
|
|
71
|
-
console.log(chalk.blue(`Starting Docker services${services.length ? ` (${services.join(', ')})` : ''}`));
|
|
72
|
-
dockerCompose(composeCommand, { envFile });
|
|
73
|
-
};
|
package/dist/commands/start.js
CHANGED
|
@@ -4,14 +4,11 @@
|
|
|
4
4
|
* Full terms: see LICENSE.md.
|
|
5
5
|
*/
|
|
6
6
|
import * as path from 'path';
|
|
7
|
-
import
|
|
8
|
-
import { loadProjectConfig
|
|
9
|
-
import {
|
|
10
|
-
import {
|
|
11
|
-
import {
|
|
12
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
13
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
14
|
-
import { parseServices } from '../utils/services.js';
|
|
7
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
8
|
+
import { loadProjectConfig } from '../core/config.js';
|
|
9
|
+
import { runPackageScript } from '../core/package-manager.js';
|
|
10
|
+
import { bootstrapProjectEnv, resolveProjectPackageManager, } from '../core/project-run.js';
|
|
11
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
15
12
|
export const registerStartCommand = (program) => {
|
|
16
13
|
program
|
|
17
14
|
.command('start')
|
|
@@ -31,47 +28,26 @@ export const runStart = async (options = {}) => {
|
|
|
31
28
|
const projectRoot = path.resolve(options.cwd || process.cwd());
|
|
32
29
|
assertHexabotProject(projectRoot);
|
|
33
30
|
const config = loadProjectConfig(projectRoot);
|
|
34
|
-
const
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
updateProjectConfig(projectRoot, { packageManager: pm });
|
|
31
|
+
const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
|
|
32
|
+
if (options.envBootstrap) {
|
|
33
|
+
bootstrapProjectEnv(projectRoot, config, options);
|
|
38
34
|
}
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
if (options.
|
|
42
|
-
|
|
35
|
+
if (options.docker) {
|
|
36
|
+
const upArgs = ['up'];
|
|
37
|
+
if (options.build) {
|
|
38
|
+
upArgs.push('--build');
|
|
43
39
|
}
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
|
|
47
|
-
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
40
|
+
if (options.detach) {
|
|
41
|
+
upArgs.push('-d');
|
|
48
42
|
}
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
43
|
+
runProjectCompose(projectRoot, config, {
|
|
44
|
+
services: options.services,
|
|
45
|
+
mode: 'prod',
|
|
46
|
+
args: upArgs,
|
|
47
|
+
action: 'Starting Docker services in production mode',
|
|
48
|
+
});
|
|
52
49
|
}
|
|
53
50
|
else {
|
|
54
51
|
runPackageScript(pm, config.startScript, projectRoot);
|
|
55
52
|
}
|
|
56
53
|
};
|
|
57
|
-
const runDockerStart = async (projectRoot, options, config) => {
|
|
58
|
-
checkDocker({ silent: true });
|
|
59
|
-
ensureDockerFolder(projectRoot);
|
|
60
|
-
const servicesInput = parseServices(options.services || '');
|
|
61
|
-
const services = servicesInput.length
|
|
62
|
-
? servicesInput
|
|
63
|
-
: config.docker.defaultServices;
|
|
64
|
-
const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
|
|
65
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
66
|
-
const composeArgs = generateComposeFiles(composeFile, services, 'prod');
|
|
67
|
-
const upArgs = ['up'];
|
|
68
|
-
if (options.build) {
|
|
69
|
-
upArgs.push('--build');
|
|
70
|
-
}
|
|
71
|
-
if (options.detach) {
|
|
72
|
-
upArgs.push('-d');
|
|
73
|
-
}
|
|
74
|
-
const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
|
|
75
|
-
console.log(chalk.blue(`Starting Docker services in production mode${services.length ? ` (${services.join(', ')})` : ''}`));
|
|
76
|
-
dockerCompose(composeCommand, { envFile });
|
|
77
|
-
};
|
package/dist/commands/stop.js
CHANGED
|
@@ -5,11 +5,9 @@
|
|
|
5
5
|
*/
|
|
6
6
|
import * as path from 'path';
|
|
7
7
|
import chalk from 'chalk';
|
|
8
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
8
9
|
import { loadProjectConfig } from '../core/config.js';
|
|
9
|
-
import {
|
|
10
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
11
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
12
|
-
import { parseServices } from '../utils/services.js';
|
|
10
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
13
11
|
export const registerStopCommand = (program) => {
|
|
14
12
|
program
|
|
15
13
|
.command('stop')
|
|
@@ -31,18 +29,6 @@ export const runStop = async (options = {}) => {
|
|
|
31
29
|
process.exit(1);
|
|
32
30
|
}
|
|
33
31
|
const config = loadProjectConfig(projectRoot);
|
|
34
|
-
await runDockerStop(projectRoot, options, config);
|
|
35
|
-
};
|
|
36
|
-
const runDockerStop = async (projectRoot, options, config) => {
|
|
37
|
-
checkDocker({ silent: true });
|
|
38
|
-
ensureDockerFolder(projectRoot);
|
|
39
|
-
const servicesInput = parseServices(options.services || '');
|
|
40
|
-
const services = servicesInput.length
|
|
41
|
-
? servicesInput
|
|
42
|
-
: config.docker.defaultServices;
|
|
43
|
-
const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
|
|
44
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
45
|
-
const composeArgs = generateComposeFiles(composeFile, services);
|
|
46
32
|
const downArgs = ['down'];
|
|
47
33
|
if (options.volumes) {
|
|
48
34
|
downArgs.push('--volumes');
|
|
@@ -50,7 +36,9 @@ const runDockerStop = async (projectRoot, options, config) => {
|
|
|
50
36
|
if (options.removeOrphans) {
|
|
51
37
|
downArgs.push('--remove-orphans');
|
|
52
38
|
}
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
39
|
+
runProjectCompose(projectRoot, config, {
|
|
40
|
+
services: options.services,
|
|
41
|
+
args: downArgs,
|
|
42
|
+
action: 'Stopping Docker services',
|
|
43
|
+
});
|
|
56
44
|
};
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Hexabot — Fair Core License (FCL-1.0-ALv2)
|
|
3
|
+
* Copyright (c) 2026 Hexastack.
|
|
4
|
+
* Full terms: see LICENSE.md.
|
|
5
|
+
*/
|
|
6
|
+
import chalk from 'chalk';
|
|
7
|
+
import { parseServices } from '../utils/services.js';
|
|
8
|
+
import { dockerCompose, generateComposeFiles, resolveComposeEnvFile, resolveComposeFile, } from './docker.js';
|
|
9
|
+
import { checkDocker } from './prerequisites.js';
|
|
10
|
+
import { ensureDockerFolder } from './project.js';
|
|
11
|
+
/**
|
|
12
|
+
* Runs `docker compose <args>` over the project's compose files for the
|
|
13
|
+
* requested services, or the configured default services.
|
|
14
|
+
*/
|
|
15
|
+
export const runProjectCompose = (projectRoot, config, { services: servicesOption, mode, args, action, }) => {
|
|
16
|
+
checkDocker({ silent: true });
|
|
17
|
+
ensureDockerFolder(projectRoot);
|
|
18
|
+
const servicesInput = parseServices(servicesOption || '');
|
|
19
|
+
const services = servicesInput.length
|
|
20
|
+
? servicesInput
|
|
21
|
+
: config.docker.defaultServices;
|
|
22
|
+
const composeFile = resolveComposeFile(projectRoot, config.docker.composeFile);
|
|
23
|
+
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
24
|
+
const composeArgs = mode
|
|
25
|
+
? generateComposeFiles(composeFile, services, mode)
|
|
26
|
+
: generateComposeFiles(composeFile, services);
|
|
27
|
+
const composeCommand = `${composeArgs} ${args.join(' ')}`.trim();
|
|
28
|
+
console.log(chalk.blue(`${action}${services.length ? ` (${services.join(', ')})` : ''}`));
|
|
29
|
+
dockerCompose(composeCommand, { envFile });
|
|
30
|
+
};
|
package/dist/core/config.js
CHANGED
|
@@ -52,7 +52,7 @@ export const ensureProjectConfig = (projectRoot = process.cwd(), overrides = {})
|
|
|
52
52
|
}
|
|
53
53
|
return loadProjectConfig(projectRoot);
|
|
54
54
|
};
|
|
55
|
-
|
|
55
|
+
const writeProjectConfig = (config, projectRoot = process.cwd()) => {
|
|
56
56
|
const configPath = resolveConfigPath(projectRoot);
|
|
57
57
|
fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
|
|
58
58
|
};
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Hexabot — Fair Core License (FCL-1.0-ALv2)
|
|
3
|
+
* Copyright (c) 2026 Hexastack.
|
|
4
|
+
* Full terms: see LICENSE.md.
|
|
5
|
+
*/
|
|
6
|
+
import { updateProjectConfig } from './config.js';
|
|
7
|
+
import { bootstrapEnvFile, resolveEnvExample } from './env.js';
|
|
8
|
+
import { detectPackageManager, normalizePackageManager, } from './package-manager.js';
|
|
9
|
+
/**
|
|
10
|
+
* Picks the package manager (`--pm`, then the project config, then the
|
|
11
|
+
* lockfile) and records it in the project config.
|
|
12
|
+
*/
|
|
13
|
+
export const resolveProjectPackageManager = (projectRoot, config, pmOption) => {
|
|
14
|
+
const pm = normalizePackageManager(pmOption) ||
|
|
15
|
+
config.packageManager ||
|
|
16
|
+
detectPackageManager(projectRoot);
|
|
17
|
+
if (config.packageManager !== pm) {
|
|
18
|
+
updateProjectConfig(projectRoot, { packageManager: pm });
|
|
19
|
+
}
|
|
20
|
+
return pm;
|
|
21
|
+
};
|
|
22
|
+
/** Creates the Docker or local env file from its example when it is missing. */
|
|
23
|
+
export const bootstrapProjectEnv = (projectRoot, config, options) => {
|
|
24
|
+
if (options.docker) {
|
|
25
|
+
bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
|
|
26
|
+
return;
|
|
27
|
+
}
|
|
28
|
+
const envFile = options.env || config.env.local;
|
|
29
|
+
const envExample = resolveEnvExample(projectRoot, envFile, config.env.localExample);
|
|
30
|
+
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
31
|
+
};
|
package/dist/core/project.js
CHANGED
|
@@ -8,9 +8,6 @@ import * as path from 'path';
|
|
|
8
8
|
import chalk from 'chalk';
|
|
9
9
|
const DOCKER_FOLDER_NAME = 'docker';
|
|
10
10
|
const HEXABOT_PACKAGE = '@hexabot-ai/api';
|
|
11
|
-
export const resolveProjectRoot = (cwd = process.cwd()) => {
|
|
12
|
-
return path.resolve(cwd);
|
|
13
|
-
};
|
|
14
11
|
export const readPackageJson = (projectRoot = process.cwd()) => {
|
|
15
12
|
try {
|
|
16
13
|
const packageJsonPath = path.join(projectRoot, 'package.json');
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@hexabot-ai/cli",
|
|
3
|
-
"version": "3.
|
|
3
|
+
"version": "3.7.0-beta.0",
|
|
4
4
|
"description": "Official Hexabot CLI for creating and managing AI chatbot/agent projects built with Hexabot.",
|
|
5
5
|
"main": "dist/index.js",
|
|
6
6
|
"type": "module",
|
|
@@ -25,6 +25,7 @@
|
|
|
25
25
|
"figlet": "^1.12.0"
|
|
26
26
|
},
|
|
27
27
|
"devDependencies": {
|
|
28
|
+
"@eslint/eslintrc": "^3.3.1",
|
|
28
29
|
"@jest/globals": "^30.4.1",
|
|
29
30
|
"@types/figlet": "^1.5.8",
|
|
30
31
|
"@types/jest": "^30.0.0",
|
|
@@ -37,6 +38,7 @@
|
|
|
37
38
|
"eslint-plugin-header": "^3.1.1",
|
|
38
39
|
"eslint-plugin-import": "^2.32.0",
|
|
39
40
|
"eslint-plugin-prettier": "^5.5.4",
|
|
41
|
+
"globals": "^14.0.0",
|
|
40
42
|
"jest": "^30.2.0",
|
|
41
43
|
"lint-staged": "^15.3.0",
|
|
42
44
|
"prettier": "^3.6.2",
|
package/src/commands/dev.ts
CHANGED
|
@@ -6,25 +6,16 @@
|
|
|
6
6
|
|
|
7
7
|
import * as path from 'path';
|
|
8
8
|
|
|
9
|
-
import chalk from 'chalk';
|
|
10
9
|
import { Command } from 'commander';
|
|
11
10
|
|
|
12
|
-
import {
|
|
11
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
12
|
+
import { loadProjectConfig } from '../core/config.js';
|
|
13
|
+
import { runPackageScript } from '../core/package-manager.js';
|
|
13
14
|
import {
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
} from '../core/docker.js';
|
|
19
|
-
import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
|
|
20
|
-
import {
|
|
21
|
-
detectPackageManager,
|
|
22
|
-
normalizePackageManager,
|
|
23
|
-
runPackageScript,
|
|
24
|
-
} from '../core/package-manager.js';
|
|
25
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
26
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
27
|
-
import { parseServices } from '../utils/services.js';
|
|
15
|
+
bootstrapProjectEnv,
|
|
16
|
+
resolveProjectPackageManager,
|
|
17
|
+
} from '../core/project-run.js';
|
|
18
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
28
19
|
|
|
29
20
|
export interface DevOptions {
|
|
30
21
|
docker?: boolean;
|
|
@@ -58,67 +49,25 @@ export const runDev = async (options: DevOptions = {}) => {
|
|
|
58
49
|
const projectRoot = path.resolve(options.cwd || process.cwd());
|
|
59
50
|
assertHexabotProject(projectRoot);
|
|
60
51
|
const config = loadProjectConfig(projectRoot);
|
|
61
|
-
const
|
|
62
|
-
const pm =
|
|
63
|
-
normalizedPm || config.packageManager || detectPackageManager(projectRoot);
|
|
52
|
+
const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
|
|
64
53
|
|
|
65
|
-
if (
|
|
66
|
-
|
|
54
|
+
if (options.envBootstrap !== false) {
|
|
55
|
+
bootstrapProjectEnv(projectRoot, config, options);
|
|
67
56
|
}
|
|
68
57
|
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
if (options.
|
|
72
|
-
|
|
73
|
-
projectRoot,
|
|
74
|
-
config.env.dockerExample,
|
|
75
|
-
config.env.docker,
|
|
76
|
-
);
|
|
77
|
-
} else {
|
|
78
|
-
const envFile = options.env || config.env.local;
|
|
79
|
-
const envExample = resolveEnvExample(
|
|
80
|
-
projectRoot,
|
|
81
|
-
envFile,
|
|
82
|
-
config.env.localExample,
|
|
83
|
-
);
|
|
84
|
-
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
58
|
+
if (options.docker) {
|
|
59
|
+
const upArgs = ['up', '--build'];
|
|
60
|
+
if (options.detach) {
|
|
61
|
+
upArgs.push('-d');
|
|
85
62
|
}
|
|
86
|
-
}
|
|
87
63
|
|
|
88
|
-
|
|
89
|
-
|
|
64
|
+
runProjectCompose(projectRoot, config, {
|
|
65
|
+
services: options.services,
|
|
66
|
+
mode: 'dev',
|
|
67
|
+
args: upArgs,
|
|
68
|
+
action: 'Starting Docker services',
|
|
69
|
+
});
|
|
90
70
|
} else {
|
|
91
71
|
runPackageScript(pm, config.devScript, projectRoot);
|
|
92
72
|
}
|
|
93
73
|
};
|
|
94
|
-
|
|
95
|
-
const runDockerDev = async (
|
|
96
|
-
projectRoot: string,
|
|
97
|
-
options: DevOptions,
|
|
98
|
-
config: ReturnType<typeof loadProjectConfig>,
|
|
99
|
-
) => {
|
|
100
|
-
checkDocker({ silent: true });
|
|
101
|
-
ensureDockerFolder(projectRoot);
|
|
102
|
-
const servicesInput = parseServices(options.services || '');
|
|
103
|
-
const services = servicesInput.length
|
|
104
|
-
? servicesInput
|
|
105
|
-
: config.docker.defaultServices;
|
|
106
|
-
const composeFile = resolveComposeFile(
|
|
107
|
-
projectRoot,
|
|
108
|
-
config.docker.composeFile,
|
|
109
|
-
);
|
|
110
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
111
|
-
const composeArgs = generateComposeFiles(composeFile, services, 'dev');
|
|
112
|
-
const upArgs = ['up', '--build'];
|
|
113
|
-
if (options.detach) {
|
|
114
|
-
upArgs.push('-d');
|
|
115
|
-
}
|
|
116
|
-
|
|
117
|
-
const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
|
|
118
|
-
console.log(
|
|
119
|
-
chalk.blue(
|
|
120
|
-
`Starting Docker services${services.length ? ` (${services.join(', ')})` : ''}`,
|
|
121
|
-
),
|
|
122
|
-
);
|
|
123
|
-
dockerCompose(composeCommand, { envFile });
|
|
124
|
-
};
|
package/src/commands/start.ts
CHANGED
|
@@ -6,25 +6,16 @@
|
|
|
6
6
|
|
|
7
7
|
import * as path from 'path';
|
|
8
8
|
|
|
9
|
-
import chalk from 'chalk';
|
|
10
9
|
import { Command } from 'commander';
|
|
11
10
|
|
|
12
|
-
import {
|
|
11
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
12
|
+
import { loadProjectConfig } from '../core/config.js';
|
|
13
|
+
import { runPackageScript } from '../core/package-manager.js';
|
|
13
14
|
import {
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
} from '../core/docker.js';
|
|
19
|
-
import { bootstrapEnvFile, resolveEnvExample } from '../core/env.js';
|
|
20
|
-
import {
|
|
21
|
-
detectPackageManager,
|
|
22
|
-
normalizePackageManager,
|
|
23
|
-
runPackageScript,
|
|
24
|
-
} from '../core/package-manager.js';
|
|
25
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
26
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
27
|
-
import { parseServices } from '../utils/services.js';
|
|
15
|
+
bootstrapProjectEnv,
|
|
16
|
+
resolveProjectPackageManager,
|
|
17
|
+
} from '../core/project-run.js';
|
|
18
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
28
19
|
|
|
29
20
|
export interface StartOptions {
|
|
30
21
|
docker?: boolean;
|
|
@@ -57,72 +48,28 @@ export const runStart = async (options: StartOptions = {}) => {
|
|
|
57
48
|
const projectRoot = path.resolve(options.cwd || process.cwd());
|
|
58
49
|
assertHexabotProject(projectRoot);
|
|
59
50
|
const config = loadProjectConfig(projectRoot);
|
|
60
|
-
const
|
|
61
|
-
const pm =
|
|
62
|
-
normalizedPm || config.packageManager || detectPackageManager(projectRoot);
|
|
51
|
+
const pm = resolveProjectPackageManager(projectRoot, config, options.pm);
|
|
63
52
|
|
|
64
|
-
if (
|
|
65
|
-
|
|
53
|
+
if (options.envBootstrap) {
|
|
54
|
+
bootstrapProjectEnv(projectRoot, config, options);
|
|
66
55
|
}
|
|
67
56
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
if (options.
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
);
|
|
76
|
-
} else {
|
|
77
|
-
const envFile = options.env || config.env.local;
|
|
78
|
-
const envExample = resolveEnvExample(
|
|
79
|
-
projectRoot,
|
|
80
|
-
envFile,
|
|
81
|
-
config.env.localExample,
|
|
82
|
-
);
|
|
83
|
-
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
57
|
+
if (options.docker) {
|
|
58
|
+
const upArgs = ['up'];
|
|
59
|
+
if (options.build) {
|
|
60
|
+
upArgs.push('--build');
|
|
61
|
+
}
|
|
62
|
+
if (options.detach) {
|
|
63
|
+
upArgs.push('-d');
|
|
84
64
|
}
|
|
85
|
-
}
|
|
86
65
|
|
|
87
|
-
|
|
88
|
-
|
|
66
|
+
runProjectCompose(projectRoot, config, {
|
|
67
|
+
services: options.services,
|
|
68
|
+
mode: 'prod',
|
|
69
|
+
args: upArgs,
|
|
70
|
+
action: 'Starting Docker services in production mode',
|
|
71
|
+
});
|
|
89
72
|
} else {
|
|
90
73
|
runPackageScript(pm, config.startScript, projectRoot);
|
|
91
74
|
}
|
|
92
75
|
};
|
|
93
|
-
|
|
94
|
-
const runDockerStart = async (
|
|
95
|
-
projectRoot: string,
|
|
96
|
-
options: StartOptions,
|
|
97
|
-
config: ReturnType<typeof loadProjectConfig>,
|
|
98
|
-
) => {
|
|
99
|
-
checkDocker({ silent: true });
|
|
100
|
-
ensureDockerFolder(projectRoot);
|
|
101
|
-
const servicesInput = parseServices(options.services || '');
|
|
102
|
-
const services = servicesInput.length
|
|
103
|
-
? servicesInput
|
|
104
|
-
: config.docker.defaultServices;
|
|
105
|
-
const composeFile = resolveComposeFile(
|
|
106
|
-
projectRoot,
|
|
107
|
-
config.docker.composeFile,
|
|
108
|
-
);
|
|
109
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
110
|
-
const composeArgs = generateComposeFiles(composeFile, services, 'prod');
|
|
111
|
-
const upArgs = ['up'];
|
|
112
|
-
if (options.build) {
|
|
113
|
-
upArgs.push('--build');
|
|
114
|
-
}
|
|
115
|
-
if (options.detach) {
|
|
116
|
-
upArgs.push('-d');
|
|
117
|
-
}
|
|
118
|
-
|
|
119
|
-
const composeCommand = `${composeArgs} ${upArgs.join(' ')}`.trim();
|
|
120
|
-
console.log(
|
|
121
|
-
chalk.blue(
|
|
122
|
-
`Starting Docker services in production mode${
|
|
123
|
-
services.length ? ` (${services.join(', ')})` : ''
|
|
124
|
-
}`,
|
|
125
|
-
),
|
|
126
|
-
);
|
|
127
|
-
dockerCompose(composeCommand, { envFile });
|
|
128
|
-
};
|
package/src/commands/stop.ts
CHANGED
|
@@ -9,16 +9,9 @@ import * as path from 'path';
|
|
|
9
9
|
import chalk from 'chalk';
|
|
10
10
|
import { Command } from 'commander';
|
|
11
11
|
|
|
12
|
+
import { runProjectCompose } from '../core/compose.js';
|
|
12
13
|
import { loadProjectConfig } from '../core/config.js';
|
|
13
|
-
import {
|
|
14
|
-
dockerCompose,
|
|
15
|
-
generateComposeFiles,
|
|
16
|
-
resolveComposeEnvFile,
|
|
17
|
-
resolveComposeFile,
|
|
18
|
-
} from '../core/docker.js';
|
|
19
|
-
import { checkDocker } from '../core/prerequisites.js';
|
|
20
|
-
import { assertHexabotProject, ensureDockerFolder } from '../core/project.js';
|
|
21
|
-
import { parseServices } from '../utils/services.js';
|
|
14
|
+
import { assertHexabotProject } from '../core/project.js';
|
|
22
15
|
|
|
23
16
|
export interface StopOptions {
|
|
24
17
|
docker?: boolean;
|
|
@@ -56,26 +49,6 @@ export const runStop = async (options: StopOptions = {}) => {
|
|
|
56
49
|
}
|
|
57
50
|
|
|
58
51
|
const config = loadProjectConfig(projectRoot);
|
|
59
|
-
await runDockerStop(projectRoot, options, config);
|
|
60
|
-
};
|
|
61
|
-
|
|
62
|
-
const runDockerStop = async (
|
|
63
|
-
projectRoot: string,
|
|
64
|
-
options: StopOptions,
|
|
65
|
-
config: ReturnType<typeof loadProjectConfig>,
|
|
66
|
-
) => {
|
|
67
|
-
checkDocker({ silent: true });
|
|
68
|
-
ensureDockerFolder(projectRoot);
|
|
69
|
-
const servicesInput = parseServices(options.services || '');
|
|
70
|
-
const services = servicesInput.length
|
|
71
|
-
? servicesInput
|
|
72
|
-
: config.docker.defaultServices;
|
|
73
|
-
const composeFile = resolveComposeFile(
|
|
74
|
-
projectRoot,
|
|
75
|
-
config.docker.composeFile,
|
|
76
|
-
);
|
|
77
|
-
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
78
|
-
const composeArgs = generateComposeFiles(composeFile, services);
|
|
79
52
|
const downArgs = ['down'];
|
|
80
53
|
if (options.volumes) {
|
|
81
54
|
downArgs.push('--volumes');
|
|
@@ -84,13 +57,9 @@ const runDockerStop = async (
|
|
|
84
57
|
downArgs.push('--remove-orphans');
|
|
85
58
|
}
|
|
86
59
|
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
}`,
|
|
93
|
-
),
|
|
94
|
-
);
|
|
95
|
-
dockerCompose(composeCommand, { envFile });
|
|
60
|
+
runProjectCompose(projectRoot, config, {
|
|
61
|
+
services: options.services,
|
|
62
|
+
args: downArgs,
|
|
63
|
+
action: 'Stopping Docker services',
|
|
64
|
+
});
|
|
96
65
|
};
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Hexabot — Fair Core License (FCL-1.0-ALv2)
|
|
3
|
+
* Copyright (c) 2026 Hexastack.
|
|
4
|
+
* Full terms: see LICENSE.md.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import chalk from 'chalk';
|
|
8
|
+
|
|
9
|
+
import { parseServices } from '../utils/services.js';
|
|
10
|
+
|
|
11
|
+
import type { HexabotConfig } from './config.js';
|
|
12
|
+
import {
|
|
13
|
+
dockerCompose,
|
|
14
|
+
generateComposeFiles,
|
|
15
|
+
resolveComposeEnvFile,
|
|
16
|
+
resolveComposeFile,
|
|
17
|
+
type ComposeMode,
|
|
18
|
+
} from './docker.js';
|
|
19
|
+
import { checkDocker } from './prerequisites.js';
|
|
20
|
+
import { ensureDockerFolder } from './project.js';
|
|
21
|
+
|
|
22
|
+
/**
|
|
23
|
+
* Runs `docker compose <args>` over the project's compose files for the
|
|
24
|
+
* requested services, or the configured default services.
|
|
25
|
+
*/
|
|
26
|
+
export const runProjectCompose = (
|
|
27
|
+
projectRoot: string,
|
|
28
|
+
config: HexabotConfig,
|
|
29
|
+
{
|
|
30
|
+
services: servicesOption,
|
|
31
|
+
mode,
|
|
32
|
+
args,
|
|
33
|
+
action,
|
|
34
|
+
}: {
|
|
35
|
+
services?: string;
|
|
36
|
+
mode?: ComposeMode;
|
|
37
|
+
args: string[];
|
|
38
|
+
/** Log prefix, e.g. "Starting Docker services". */
|
|
39
|
+
action: string;
|
|
40
|
+
},
|
|
41
|
+
) => {
|
|
42
|
+
checkDocker({ silent: true });
|
|
43
|
+
ensureDockerFolder(projectRoot);
|
|
44
|
+
const servicesInput = parseServices(servicesOption || '');
|
|
45
|
+
const services = servicesInput.length
|
|
46
|
+
? servicesInput
|
|
47
|
+
: config.docker.defaultServices;
|
|
48
|
+
const composeFile = resolveComposeFile(
|
|
49
|
+
projectRoot,
|
|
50
|
+
config.docker.composeFile,
|
|
51
|
+
);
|
|
52
|
+
const envFile = resolveComposeEnvFile(projectRoot, config.env.docker);
|
|
53
|
+
const composeArgs = mode
|
|
54
|
+
? generateComposeFiles(composeFile, services, mode)
|
|
55
|
+
: generateComposeFiles(composeFile, services);
|
|
56
|
+
const composeCommand = `${composeArgs} ${args.join(' ')}`.trim();
|
|
57
|
+
console.log(
|
|
58
|
+
chalk.blue(
|
|
59
|
+
`${action}${services.length ? ` (${services.join(', ')})` : ''}`,
|
|
60
|
+
),
|
|
61
|
+
);
|
|
62
|
+
dockerCompose(composeCommand, { envFile });
|
|
63
|
+
};
|
package/src/core/config.ts
CHANGED
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Hexabot — Fair Core License (FCL-1.0-ALv2)
|
|
3
|
+
* Copyright (c) 2026 Hexastack.
|
|
4
|
+
* Full terms: see LICENSE.md.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import { updateProjectConfig, type HexabotConfig } from './config.js';
|
|
8
|
+
import { bootstrapEnvFile, resolveEnvExample } from './env.js';
|
|
9
|
+
import {
|
|
10
|
+
detectPackageManager,
|
|
11
|
+
normalizePackageManager,
|
|
12
|
+
} from './package-manager.js';
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* Picks the package manager (`--pm`, then the project config, then the
|
|
16
|
+
* lockfile) and records it in the project config.
|
|
17
|
+
*/
|
|
18
|
+
export const resolveProjectPackageManager = (
|
|
19
|
+
projectRoot: string,
|
|
20
|
+
config: HexabotConfig,
|
|
21
|
+
pmOption?: string,
|
|
22
|
+
) => {
|
|
23
|
+
const pm =
|
|
24
|
+
normalizePackageManager(pmOption) ||
|
|
25
|
+
config.packageManager ||
|
|
26
|
+
detectPackageManager(projectRoot);
|
|
27
|
+
|
|
28
|
+
if (config.packageManager !== pm) {
|
|
29
|
+
updateProjectConfig(projectRoot, { packageManager: pm });
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
return pm;
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
/** Creates the Docker or local env file from its example when it is missing. */
|
|
36
|
+
export const bootstrapProjectEnv = (
|
|
37
|
+
projectRoot: string,
|
|
38
|
+
config: HexabotConfig,
|
|
39
|
+
options: { docker?: boolean; env?: string },
|
|
40
|
+
) => {
|
|
41
|
+
if (options.docker) {
|
|
42
|
+
bootstrapEnvFile(projectRoot, config.env.dockerExample, config.env.docker);
|
|
43
|
+
|
|
44
|
+
return;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
const envFile = options.env || config.env.local;
|
|
48
|
+
const envExample = resolveEnvExample(
|
|
49
|
+
projectRoot,
|
|
50
|
+
envFile,
|
|
51
|
+
config.env.localExample,
|
|
52
|
+
);
|
|
53
|
+
bootstrapEnvFile(projectRoot, envExample, envFile);
|
|
54
|
+
};
|
package/src/core/project.ts
CHANGED
|
@@ -19,10 +19,6 @@ export interface PackageJson {
|
|
|
19
19
|
devDependencies?: Record<string, string>;
|
|
20
20
|
}
|
|
21
21
|
|
|
22
|
-
export const resolveProjectRoot = (cwd = process.cwd()) => {
|
|
23
|
-
return path.resolve(cwd);
|
|
24
|
-
};
|
|
25
|
-
|
|
26
22
|
export const readPackageJson = (
|
|
27
23
|
projectRoot = process.cwd(),
|
|
28
24
|
): PackageJson | null => {
|