@amaster.ai/runtime-cli 1.1.13 → 1.1.14-beta.1
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/README.md +45 -1
- package/dist/cli.cjs +691 -225
- package/dist/cli.cjs.map +1 -1
- package/dist/cli.js +691 -225
- package/dist/cli.js.map +1 -1
- package/dist/index.cjs +691 -225
- package/dist/index.cjs.map +1 -1
- package/dist/index.js +691 -225
- package/dist/index.js.map +1 -1
- package/dist/skill/SKILL.md +40 -3
- package/package.json +2 -2
package/dist/cli.cjs
CHANGED
|
@@ -6,7 +6,7 @@ var path = require('path');
|
|
|
6
6
|
var os = require('os');
|
|
7
7
|
var url = require('url');
|
|
8
8
|
var commander = require('commander');
|
|
9
|
-
var
|
|
9
|
+
var chalk4 = require('chalk');
|
|
10
10
|
var client = require('@amaster.ai/client');
|
|
11
11
|
var ora = require('ora');
|
|
12
12
|
var buffer = require('buffer');
|
|
@@ -15,7 +15,7 @@ var yaml = require('yaml');
|
|
|
15
15
|
var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
|
|
16
16
|
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
|
|
17
17
|
|
|
18
|
-
var
|
|
18
|
+
var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
|
|
19
19
|
var ora__default = /*#__PURE__*/_interopDefault(ora);
|
|
20
20
|
var yaml__default = /*#__PURE__*/_interopDefault(yaml);
|
|
21
21
|
|
|
@@ -336,9 +336,9 @@ async function login(appCode, options) {
|
|
|
336
336
|
const appConfig = getAppConfig(appCode);
|
|
337
337
|
if (!appConfig) {
|
|
338
338
|
spinner.fail(`App not configured: ${appCode}`);
|
|
339
|
-
console.error(
|
|
339
|
+
console.error(chalk4__default.default.red(`
|
|
340
340
|
\u274C App not found: ${appCode}`));
|
|
341
|
-
console.log(
|
|
341
|
+
console.log(chalk4__default.default.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
|
|
342
342
|
process.exit(1);
|
|
343
343
|
}
|
|
344
344
|
let username = options.username;
|
|
@@ -387,7 +387,7 @@ async function login(appCode, options) {
|
|
|
387
387
|
const result = await client$1.auth.login(loginParams);
|
|
388
388
|
if (result.error) {
|
|
389
389
|
spinner.fail("Login failed");
|
|
390
|
-
console.error(
|
|
390
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
391
391
|
process.exit(1);
|
|
392
392
|
}
|
|
393
393
|
const loginData = result.data;
|
|
@@ -421,16 +421,16 @@ async function login(appCode, options) {
|
|
|
421
421
|
format: options.format,
|
|
422
422
|
pretty: () => {
|
|
423
423
|
console.log(
|
|
424
|
-
|
|
424
|
+
chalk4__default.default.green(
|
|
425
425
|
`
|
|
426
426
|
Welcome, ${loginData.user?.displayName || loginData.user?.email || loginData.user?.username || email}!`
|
|
427
427
|
)
|
|
428
428
|
);
|
|
429
|
-
console.log(
|
|
430
|
-
console.log(
|
|
429
|
+
console.log(chalk4__default.default.gray(`App: ${appCode}`));
|
|
430
|
+
console.log(chalk4__default.default.gray(`URL: ${appConfig.baseURL}`));
|
|
431
431
|
if (expiresAt) {
|
|
432
432
|
const expires = new Date(expiresAt);
|
|
433
|
-
console.log(
|
|
433
|
+
console.log(chalk4__default.default.gray(`Session expires: ${expires.toLocaleString()}`));
|
|
434
434
|
}
|
|
435
435
|
}
|
|
436
436
|
}
|
|
@@ -466,7 +466,7 @@ async function logout(appCode, options = {}) {
|
|
|
466
466
|
{
|
|
467
467
|
format: options.format,
|
|
468
468
|
pretty: () => {
|
|
469
|
-
console.log(
|
|
469
|
+
console.log(chalk4__default.default.green(`Logged out from ${appCode}`));
|
|
470
470
|
}
|
|
471
471
|
}
|
|
472
472
|
);
|
|
@@ -482,7 +482,7 @@ async function getMe(getClient, options = {}) {
|
|
|
482
482
|
const result = await client.auth.getMe();
|
|
483
483
|
if (result.error) {
|
|
484
484
|
spinner.fail("Failed to fetch user info");
|
|
485
|
-
console.error(
|
|
485
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
486
486
|
process.exit(1);
|
|
487
487
|
}
|
|
488
488
|
spinner.succeed("User info retrieved");
|
|
@@ -490,11 +490,11 @@ async function getMe(getClient, options = {}) {
|
|
|
490
490
|
renderOutput(user, {
|
|
491
491
|
format: options.format,
|
|
492
492
|
pretty: () => {
|
|
493
|
-
console.log(
|
|
494
|
-
console.log(` ${
|
|
495
|
-
console.log(` ${
|
|
496
|
-
console.log(` ${
|
|
497
|
-
console.log(` ${
|
|
493
|
+
console.log(chalk4__default.default.blue("\n\u{1F464} User Profile\n"));
|
|
494
|
+
console.log(` ${chalk4__default.default.bold("UID:")} ${user?.uid}`);
|
|
495
|
+
console.log(` ${chalk4__default.default.bold("Email:")} ${user?.email}`);
|
|
496
|
+
console.log(` ${chalk4__default.default.bold("Name:")} ${user?.displayName || user?.username || "N/A"}`);
|
|
497
|
+
console.log(` ${chalk4__default.default.bold("Status:")} ${user?.isActive ? "Active" : "Inactive"}`);
|
|
498
498
|
}
|
|
499
499
|
});
|
|
500
500
|
} catch (error) {
|
|
@@ -624,7 +624,7 @@ function exitWithCommandError(spinner, failureMessage, error) {
|
|
|
624
624
|
spinner.fail(failureMessage);
|
|
625
625
|
const details = error instanceof Error ? error.message : String(error);
|
|
626
626
|
if (details) {
|
|
627
|
-
console.error(
|
|
627
|
+
console.error(chalk4__default.default.red(details));
|
|
628
628
|
}
|
|
629
629
|
process.exit(1);
|
|
630
630
|
}
|
|
@@ -689,7 +689,7 @@ async function listEntities(client, options) {
|
|
|
689
689
|
});
|
|
690
690
|
if (result.error) {
|
|
691
691
|
spinner.fail("Failed to fetch entities");
|
|
692
|
-
console.error(
|
|
692
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
693
693
|
process.exit(1);
|
|
694
694
|
}
|
|
695
695
|
spinner.stop();
|
|
@@ -709,12 +709,12 @@ async function listEntities(client, options) {
|
|
|
709
709
|
renderOutput(result.data, {
|
|
710
710
|
format: options.format,
|
|
711
711
|
pretty: () => {
|
|
712
|
-
console.log(
|
|
712
|
+
console.log(chalk4__default.default.blue(`
|
|
713
713
|
\u{1F4E6} ${options.entity} in ${options.namespace}`));
|
|
714
|
-
console.log(
|
|
714
|
+
console.log(chalk4__default.default.gray(`\u5171 ${total} \u6761\u8BB0\u5F55:
|
|
715
715
|
`));
|
|
716
716
|
if (items.length === 0) {
|
|
717
|
-
console.log(
|
|
717
|
+
console.log(chalk4__default.default.gray(" \u6682\u65E0\u6570\u636E"));
|
|
718
718
|
return;
|
|
719
719
|
}
|
|
720
720
|
const firstItem = items[0];
|
|
@@ -734,7 +734,7 @@ async function listEntities(client, options) {
|
|
|
734
734
|
});
|
|
735
735
|
const headerLine = keys.map((key) => {
|
|
736
736
|
const width = widths[key] ?? 0;
|
|
737
|
-
return
|
|
737
|
+
return chalk4__default.default.bold(key.slice(0, width).padEnd(width));
|
|
738
738
|
}).join("\u2502");
|
|
739
739
|
console.log(" " + headerLine);
|
|
740
740
|
console.log(" " + keys.map((key) => "\u2500".repeat(widths[key] ?? 0)).join("\u253C"));
|
|
@@ -750,7 +750,7 @@ async function listEntities(client, options) {
|
|
|
750
750
|
}
|
|
751
751
|
console.log();
|
|
752
752
|
if (items.length < total) {
|
|
753
|
-
console.log(
|
|
753
|
+
console.log(chalk4__default.default.gray(` ... \u8FD8\u6709 ${total - items.length} \u6761\u8BB0\u5F55`));
|
|
754
754
|
}
|
|
755
755
|
}
|
|
756
756
|
});
|
|
@@ -765,14 +765,14 @@ async function getEntity(client, options) {
|
|
|
765
765
|
const result = await entityClient.get(options.namespace, options.entity, options.id);
|
|
766
766
|
if (result.error) {
|
|
767
767
|
spinner.fail("Failed to fetch entity");
|
|
768
|
-
console.error(
|
|
768
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
769
769
|
process.exit(1);
|
|
770
770
|
}
|
|
771
771
|
spinner.succeed("Entity retrieved");
|
|
772
772
|
renderOutput(result.data, {
|
|
773
773
|
format: options.format,
|
|
774
774
|
pretty: () => {
|
|
775
|
-
console.log(
|
|
775
|
+
console.log(chalk4__default.default.blue(`
|
|
776
776
|
\u{1F4C4} ${options.entity}
|
|
777
777
|
`));
|
|
778
778
|
console.log(JSON.stringify(result.data, null, 2));
|
|
@@ -790,14 +790,14 @@ async function createEntity(client, options) {
|
|
|
790
790
|
const result = await entityClient.create(options.namespace, options.entity, data);
|
|
791
791
|
if (result.error) {
|
|
792
792
|
spinner.fail("Failed to create entity");
|
|
793
|
-
console.error(
|
|
793
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
794
794
|
process.exit(1);
|
|
795
795
|
}
|
|
796
796
|
spinner.succeed("Entity created");
|
|
797
797
|
renderOutput(result.data, {
|
|
798
798
|
format: options.format,
|
|
799
799
|
pretty: () => {
|
|
800
|
-
console.log(
|
|
800
|
+
console.log(chalk4__default.default.green("\nCreated entity:"));
|
|
801
801
|
console.log(JSON.stringify(result.data, null, 2));
|
|
802
802
|
}
|
|
803
803
|
});
|
|
@@ -813,14 +813,14 @@ async function updateEntity(client, options) {
|
|
|
813
813
|
const result = await entityClient.update(options.namespace, options.entity, options.id, data);
|
|
814
814
|
if (result.error) {
|
|
815
815
|
spinner.fail("Failed to update entity");
|
|
816
|
-
console.error(
|
|
816
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
817
817
|
process.exit(1);
|
|
818
818
|
}
|
|
819
819
|
spinner.succeed("Entity updated");
|
|
820
820
|
renderOutput(result.data, {
|
|
821
821
|
format: options.format,
|
|
822
822
|
pretty: () => {
|
|
823
|
-
console.log(
|
|
823
|
+
console.log(chalk4__default.default.green("\nUpdated entity:"));
|
|
824
824
|
console.log(JSON.stringify(result.data, null, 2));
|
|
825
825
|
}
|
|
826
826
|
});
|
|
@@ -835,7 +835,7 @@ async function deleteEntity(client, options) {
|
|
|
835
835
|
const result = await entityClient.delete(options.namespace, options.entity, options.id);
|
|
836
836
|
if (result.error) {
|
|
837
837
|
spinner.fail("Failed to delete entity");
|
|
838
|
-
console.error(
|
|
838
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
839
839
|
process.exit(1);
|
|
840
840
|
}
|
|
841
841
|
spinner.succeed("Entity deleted");
|
|
@@ -849,7 +849,7 @@ async function deleteEntity(client, options) {
|
|
|
849
849
|
{
|
|
850
850
|
format: options.format,
|
|
851
851
|
pretty: () => {
|
|
852
|
-
console.log(
|
|
852
|
+
console.log(chalk4__default.default.green(`
|
|
853
853
|
Deleted ${options.entity} with ID: ${options.id}`));
|
|
854
854
|
}
|
|
855
855
|
}
|
|
@@ -866,14 +866,14 @@ async function listEntityOptions(client, options) {
|
|
|
866
866
|
const result = await entityClient.options(options.namespace, options.entity, fields);
|
|
867
867
|
if (result.error) {
|
|
868
868
|
spinner.fail("Failed to fetch entity options");
|
|
869
|
-
console.error(
|
|
869
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
870
870
|
process.exit(1);
|
|
871
871
|
}
|
|
872
872
|
spinner.succeed(`Found ${result.data?.length || 0} options`);
|
|
873
873
|
renderOutput(result.data || [], {
|
|
874
874
|
format: options.format,
|
|
875
875
|
pretty: () => {
|
|
876
|
-
console.log(
|
|
876
|
+
console.log(chalk4__default.default.blue(`
|
|
877
877
|
\u{1F9FE} ${options.entity} options
|
|
878
878
|
`));
|
|
879
879
|
console.log(JSON.stringify(result.data || [], null, 2));
|
|
@@ -896,14 +896,14 @@ async function bulkUpdateEntities(client, options) {
|
|
|
896
896
|
const result = await entityClient.bulkUpdate(options.namespace, options.entity, items);
|
|
897
897
|
if (result.error) {
|
|
898
898
|
spinner.fail("Failed to bulk update entities");
|
|
899
|
-
console.error(
|
|
899
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
900
900
|
process.exit(1);
|
|
901
901
|
}
|
|
902
902
|
spinner.succeed(`Updated ${items.length} entities`);
|
|
903
903
|
renderOutput(result.data, {
|
|
904
904
|
format: options.format,
|
|
905
905
|
pretty: () => {
|
|
906
|
-
console.log(
|
|
906
|
+
console.log(chalk4__default.default.green(`
|
|
907
907
|
Bulk updated ${items.length} ${options.entity} records:`));
|
|
908
908
|
console.log(JSON.stringify(result.data, null, 2));
|
|
909
909
|
}
|
|
@@ -920,7 +920,7 @@ async function bulkDeleteEntities(client, options) {
|
|
|
920
920
|
const result = await entityClient.bulkDelete(options.namespace, options.entity, ids);
|
|
921
921
|
if (result.error) {
|
|
922
922
|
spinner.fail("Failed to bulk delete entities");
|
|
923
|
-
console.error(
|
|
923
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
924
924
|
process.exit(1);
|
|
925
925
|
}
|
|
926
926
|
spinner.succeed(`Deleted ${ids.length} entities`);
|
|
@@ -935,7 +935,7 @@ async function bulkDeleteEntities(client, options) {
|
|
|
935
935
|
{
|
|
936
936
|
format: options.format,
|
|
937
937
|
pretty: () => {
|
|
938
|
-
console.log(
|
|
938
|
+
console.log(chalk4__default.default.green(`
|
|
939
939
|
Deleted ${ids.length} ${options.entity} records.`));
|
|
940
940
|
}
|
|
941
941
|
}
|
|
@@ -944,10 +944,165 @@ Deleted ${ids.length} ${options.entity} records.`));
|
|
|
944
944
|
exitWithCommandError(spinner, "Failed to bulk delete entities", error);
|
|
945
945
|
}
|
|
946
946
|
}
|
|
947
|
+
function resolveInputSource2(input) {
|
|
948
|
+
if (!input.startsWith("@")) {
|
|
949
|
+
return input;
|
|
950
|
+
}
|
|
951
|
+
const filePath = input.slice(1);
|
|
952
|
+
if (!filePath) {
|
|
953
|
+
throw new Error("File path is required after '@'.");
|
|
954
|
+
}
|
|
955
|
+
return fs.readFileSync(filePath, "utf8");
|
|
956
|
+
}
|
|
957
|
+
function exitWithCommandError2(spinner, failureMessage, error) {
|
|
958
|
+
spinner.fail(failureMessage);
|
|
959
|
+
const details = error instanceof Error ? error.message : String(error);
|
|
960
|
+
if (details) {
|
|
961
|
+
console.error(chalk4__default.default.red(details));
|
|
962
|
+
}
|
|
963
|
+
process.exit(1);
|
|
964
|
+
}
|
|
965
|
+
function parseTableNamesInput(input) {
|
|
966
|
+
if (!input) {
|
|
967
|
+
return void 0;
|
|
968
|
+
}
|
|
969
|
+
const source = resolveInputSource2(input).trim();
|
|
970
|
+
if (!source) {
|
|
971
|
+
return void 0;
|
|
972
|
+
}
|
|
973
|
+
if (source.startsWith("[")) {
|
|
974
|
+
let parsed;
|
|
975
|
+
try {
|
|
976
|
+
parsed = JSON.parse(source);
|
|
977
|
+
} catch (error) {
|
|
978
|
+
const reason = error instanceof Error ? error.message : String(error);
|
|
979
|
+
throw new Error(`Invalid table list: ${reason}`);
|
|
980
|
+
}
|
|
981
|
+
if (!Array.isArray(parsed)) {
|
|
982
|
+
throw new Error("Table list must be a JSON array.");
|
|
983
|
+
}
|
|
984
|
+
return parsed.map((value, index) => {
|
|
985
|
+
if (typeof value !== "string") {
|
|
986
|
+
throw new Error(`Table name at index ${index} must be a string.`);
|
|
987
|
+
}
|
|
988
|
+
return value;
|
|
989
|
+
});
|
|
990
|
+
}
|
|
991
|
+
const values = source.split(/[,\n]/).map((entry) => entry.trim()).filter(Boolean);
|
|
992
|
+
return values.length > 0 ? values : void 0;
|
|
993
|
+
}
|
|
994
|
+
async function listDatasources(client, options = {}) {
|
|
995
|
+
const spinner = createSpinner("Fetching datasources...", options.format);
|
|
996
|
+
try {
|
|
997
|
+
const result = await client.http.request({
|
|
998
|
+
url: "/api/entity/source/list_with_models",
|
|
999
|
+
method: "GET"
|
|
1000
|
+
});
|
|
1001
|
+
if (result.error) {
|
|
1002
|
+
spinner.fail("Failed to fetch datasources");
|
|
1003
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1004
|
+
process.exit(1);
|
|
1005
|
+
}
|
|
1006
|
+
const datasources = result.data || [];
|
|
1007
|
+
spinner.succeed(`Found ${datasources.length} datasource${datasources.length === 1 ? "" : "s"}`);
|
|
1008
|
+
renderOutput(datasources, {
|
|
1009
|
+
format: options.format,
|
|
1010
|
+
tableRows: datasources.map((source) => ({
|
|
1011
|
+
sourceId: source.sourceId,
|
|
1012
|
+
name: source.name,
|
|
1013
|
+
systemBuilt: source.systemBuilt,
|
|
1014
|
+
synchronizeMode: source.synchronizeMode,
|
|
1015
|
+
modelCount: source.models?.length || 0
|
|
1016
|
+
})),
|
|
1017
|
+
csvRows: datasources.map((source) => ({
|
|
1018
|
+
sourceId: source.sourceId,
|
|
1019
|
+
name: source.name,
|
|
1020
|
+
systemBuilt: source.systemBuilt,
|
|
1021
|
+
synchronizeMode: source.synchronizeMode,
|
|
1022
|
+
modelCount: source.models?.length || 0
|
|
1023
|
+
})),
|
|
1024
|
+
ndjsonItems: datasources,
|
|
1025
|
+
pretty: () => {
|
|
1026
|
+
console.log(chalk4__default.default.blue("\nData Sources\n"));
|
|
1027
|
+
if (datasources.length === 0) {
|
|
1028
|
+
console.log(chalk4__default.default.gray("No datasources found."));
|
|
1029
|
+
return;
|
|
1030
|
+
}
|
|
1031
|
+
for (const source of datasources) {
|
|
1032
|
+
console.log(`${chalk4__default.default.green("\u2022")} ${chalk4__default.default.bold(source.name)} ${chalk4__default.default.gray(`(${source.sourceId})`)}`);
|
|
1033
|
+
console.log(` ${chalk4__default.default.gray("System Built:")} ${source.systemBuilt}`);
|
|
1034
|
+
console.log(` ${chalk4__default.default.gray("Sync Mode:")} ${source.synchronizeMode}`);
|
|
1035
|
+
if (!source.models || source.models.length === 0) {
|
|
1036
|
+
console.log(` ${chalk4__default.default.gray("Models:")} none`);
|
|
1037
|
+
continue;
|
|
1038
|
+
}
|
|
1039
|
+
console.log(` ${chalk4__default.default.gray("Models:")}`);
|
|
1040
|
+
for (const model of source.models) {
|
|
1041
|
+
const suffix = model.description ? ` ${chalk4__default.default.gray(`- ${model.description}`)}` : "";
|
|
1042
|
+
console.log(` - ${chalk4__default.default.bold(model.tableName)} ${chalk4__default.default.gray(`(${model.modelId})`)}${suffix}`);
|
|
1043
|
+
}
|
|
1044
|
+
}
|
|
1045
|
+
}
|
|
1046
|
+
});
|
|
1047
|
+
} catch (error) {
|
|
1048
|
+
exitWithCommandError2(spinner, "Failed to fetch datasources", error);
|
|
1049
|
+
}
|
|
1050
|
+
}
|
|
1051
|
+
async function getTableSchema(client, options) {
|
|
1052
|
+
const spinner = createSpinner(`Fetching table schema for ${options.sourceId}...`, options.format);
|
|
1053
|
+
try {
|
|
1054
|
+
const tableNames = parseTableNamesInput(options.tables);
|
|
1055
|
+
const search = new URLSearchParams();
|
|
1056
|
+
if (tableNames && tableNames.length > 0) {
|
|
1057
|
+
search.set("tableNames", tableNames.join(","));
|
|
1058
|
+
}
|
|
1059
|
+
const query = search.toString();
|
|
1060
|
+
const url = `/api/entity/source/${encodeURIComponent(options.sourceId)}/create_table_statements${query ? `?${query}` : ""}`;
|
|
1061
|
+
const result = await client.http.request({
|
|
1062
|
+
url,
|
|
1063
|
+
method: "GET"
|
|
1064
|
+
});
|
|
1065
|
+
if (result.error) {
|
|
1066
|
+
spinner.fail("Failed to fetch table schema");
|
|
1067
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1068
|
+
process.exit(1);
|
|
1069
|
+
}
|
|
1070
|
+
const tables = result.data || [];
|
|
1071
|
+
spinner.succeed(`Fetched schema for ${tables.length} table${tables.length === 1 ? "" : "s"}`);
|
|
1072
|
+
renderOutput(tables, {
|
|
1073
|
+
format: options.format,
|
|
1074
|
+
tableRows: tables.map((table) => ({
|
|
1075
|
+
tableName: table.tableName,
|
|
1076
|
+
createTableSql: table.createTableSql
|
|
1077
|
+
})),
|
|
1078
|
+
csvRows: tables.map((table) => ({
|
|
1079
|
+
tableName: table.tableName,
|
|
1080
|
+
createTableSql: table.createTableSql
|
|
1081
|
+
})),
|
|
1082
|
+
ndjsonItems: tables,
|
|
1083
|
+
pretty: () => {
|
|
1084
|
+
console.log(chalk4__default.default.blue(`
|
|
1085
|
+
Table Schemas: ${options.sourceId}
|
|
1086
|
+
`));
|
|
1087
|
+
if (tables.length === 0) {
|
|
1088
|
+
console.log(chalk4__default.default.gray("No tables found."));
|
|
1089
|
+
return;
|
|
1090
|
+
}
|
|
1091
|
+
for (const table of tables) {
|
|
1092
|
+
console.log(chalk4__default.default.green(table.tableName));
|
|
1093
|
+
console.log(table.createTableSql);
|
|
1094
|
+
console.log();
|
|
1095
|
+
}
|
|
1096
|
+
}
|
|
1097
|
+
});
|
|
1098
|
+
} catch (error) {
|
|
1099
|
+
exitWithCommandError2(spinner, "Failed to fetch table schema", error);
|
|
1100
|
+
}
|
|
1101
|
+
}
|
|
947
1102
|
function isPlainObject3(value) {
|
|
948
1103
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
949
1104
|
}
|
|
950
|
-
function
|
|
1105
|
+
function resolveInputSource3(input) {
|
|
951
1106
|
if (!input.startsWith("@")) {
|
|
952
1107
|
return input;
|
|
953
1108
|
}
|
|
@@ -958,7 +1113,7 @@ function resolveInputSource2(input) {
|
|
|
958
1113
|
return fs.readFileSync(filePath, "utf8");
|
|
959
1114
|
}
|
|
960
1115
|
function parseJsonInput2(input, label) {
|
|
961
|
-
const source =
|
|
1116
|
+
const source = resolveInputSource3(input).trim();
|
|
962
1117
|
if (!source) {
|
|
963
1118
|
throw new Error(`${label} is required.`);
|
|
964
1119
|
}
|
|
@@ -999,11 +1154,11 @@ function loadOptionalJsonObjectInput2(input, label) {
|
|
|
999
1154
|
}
|
|
1000
1155
|
return value;
|
|
1001
1156
|
}
|
|
1002
|
-
function
|
|
1157
|
+
function exitWithCommandError3(spinner, failureMessage, error) {
|
|
1003
1158
|
spinner.fail(failureMessage);
|
|
1004
1159
|
const details = error instanceof Error ? error.message : String(error);
|
|
1005
1160
|
if (details) {
|
|
1006
|
-
console.error(
|
|
1161
|
+
console.error(chalk4__default.default.red(details));
|
|
1007
1162
|
}
|
|
1008
1163
|
process.exit(1);
|
|
1009
1164
|
}
|
|
@@ -1012,7 +1167,7 @@ function extractClientErrorMessage(error) {
|
|
|
1012
1167
|
}
|
|
1013
1168
|
function exitWithClientError(spinner, failureMessage, error, diagnosticMessage) {
|
|
1014
1169
|
spinner.fail(failureMessage);
|
|
1015
|
-
console.error(
|
|
1170
|
+
console.error(chalk4__default.default.red(diagnosticMessage || extractClientErrorMessage(error)));
|
|
1016
1171
|
process.exit(1);
|
|
1017
1172
|
}
|
|
1018
1173
|
function inspectStartEventFormConfiguration(bpmnXml) {
|
|
@@ -1193,7 +1348,7 @@ async function listProcesses(client, options = {}) {
|
|
|
1193
1348
|
const result = await bpmClient.getProcessDefinitions(params);
|
|
1194
1349
|
if (result.error) {
|
|
1195
1350
|
spinner.fail("Failed to fetch processes");
|
|
1196
|
-
console.error(
|
|
1351
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1197
1352
|
process.exit(1);
|
|
1198
1353
|
}
|
|
1199
1354
|
spinner.succeed(`Found ${result.data?.length || 0} process definitions`);
|
|
@@ -1201,19 +1356,19 @@ async function listProcesses(client, options = {}) {
|
|
|
1201
1356
|
renderOutput(processes, {
|
|
1202
1357
|
format: options.format,
|
|
1203
1358
|
pretty: () => {
|
|
1204
|
-
console.log(
|
|
1359
|
+
console.log(chalk4__default.default.blue("\n\u{1F4CA} Process Definitions\n"));
|
|
1205
1360
|
for (const proc of processes) {
|
|
1206
|
-
console.log(` ${
|
|
1207
|
-
console.log(` ${
|
|
1208
|
-
console.log(` ${
|
|
1209
|
-
console.log(` ${
|
|
1210
|
-
console.log(` ${
|
|
1361
|
+
console.log(` ${chalk4__default.default.green("\u2022")} ${chalk4__default.default.bold(proc.key)}`);
|
|
1362
|
+
console.log(` ${chalk4__default.default.gray("ID:")} ${proc.id || "N/A"}`);
|
|
1363
|
+
console.log(` ${chalk4__default.default.gray("Name:")} ${proc.name || "N/A"}`);
|
|
1364
|
+
console.log(` ${chalk4__default.default.gray("Version:")} ${proc.version || "N/A"}`);
|
|
1365
|
+
console.log(` ${chalk4__default.default.gray("Suspended:")} ${proc.suspended ? "Yes" : "No"}`);
|
|
1211
1366
|
console.log();
|
|
1212
1367
|
}
|
|
1213
1368
|
}
|
|
1214
1369
|
});
|
|
1215
1370
|
} catch (error) {
|
|
1216
|
-
|
|
1371
|
+
exitWithCommandError3(spinner, "Failed to fetch processes", error);
|
|
1217
1372
|
}
|
|
1218
1373
|
}
|
|
1219
1374
|
async function getProcessXml(client, options) {
|
|
@@ -1223,21 +1378,21 @@ async function getProcessXml(client, options) {
|
|
|
1223
1378
|
const result = await bpmClient.getProcessXml(options.key);
|
|
1224
1379
|
if (result.error) {
|
|
1225
1380
|
spinner.fail("Failed to fetch process XML");
|
|
1226
|
-
console.error(
|
|
1381
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1227
1382
|
process.exit(1);
|
|
1228
1383
|
}
|
|
1229
1384
|
spinner.succeed("Process XML retrieved");
|
|
1230
1385
|
renderOutput(result.data, {
|
|
1231
1386
|
format: options.format,
|
|
1232
1387
|
pretty: () => {
|
|
1233
|
-
console.log(
|
|
1388
|
+
console.log(chalk4__default.default.blue(`
|
|
1234
1389
|
\u{1F4C4} BPMN XML: ${options.key}
|
|
1235
1390
|
`));
|
|
1236
1391
|
console.log(result.data?.bpmn20Xml || "");
|
|
1237
1392
|
}
|
|
1238
1393
|
});
|
|
1239
1394
|
} catch (error) {
|
|
1240
|
-
|
|
1395
|
+
exitWithCommandError3(spinner, "Failed to fetch process XML", error);
|
|
1241
1396
|
}
|
|
1242
1397
|
}
|
|
1243
1398
|
async function startProcess(client, options) {
|
|
@@ -1248,22 +1403,22 @@ async function startProcess(client, options) {
|
|
|
1248
1403
|
const result = await bpmClient.startProcess(options.key, variables);
|
|
1249
1404
|
if (result.error) {
|
|
1250
1405
|
spinner.fail("Failed to start process");
|
|
1251
|
-
console.error(
|
|
1406
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1252
1407
|
process.exit(1);
|
|
1253
1408
|
}
|
|
1254
1409
|
spinner.succeed("Process started");
|
|
1255
1410
|
renderOutput(result.data, {
|
|
1256
1411
|
format: options.format,
|
|
1257
1412
|
pretty: () => {
|
|
1258
|
-
console.log(
|
|
1259
|
-
console.log(` ${
|
|
1260
|
-
console.log(` ${
|
|
1261
|
-
console.log(` ${
|
|
1262
|
-
console.log(` ${
|
|
1413
|
+
console.log(chalk4__default.default.green("\nProcess Instance:"));
|
|
1414
|
+
console.log(` ${chalk4__default.default.bold("ID:")} ${result.data?.id}`);
|
|
1415
|
+
console.log(` ${chalk4__default.default.bold("Definition ID:")} ${result.data?.definitionId}`);
|
|
1416
|
+
console.log(` ${chalk4__default.default.bold("Business Key:")} ${result.data?.businessKey || "N/A"}`);
|
|
1417
|
+
console.log(` ${chalk4__default.default.bold("Status:")} ${result.data?.suspended ? "Suspended" : "Active"}`);
|
|
1263
1418
|
}
|
|
1264
1419
|
});
|
|
1265
1420
|
} catch (error) {
|
|
1266
|
-
|
|
1421
|
+
exitWithCommandError3(spinner, "Failed to start process", error);
|
|
1267
1422
|
}
|
|
1268
1423
|
}
|
|
1269
1424
|
async function listProcessInstances(client, options = {}) {
|
|
@@ -1274,7 +1429,7 @@ async function listProcessInstances(client, options = {}) {
|
|
|
1274
1429
|
const result = await bpmClient.getProcessInstances(params);
|
|
1275
1430
|
if (result.error) {
|
|
1276
1431
|
spinner.fail("Failed to fetch process instances");
|
|
1277
|
-
console.error(
|
|
1432
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1278
1433
|
process.exit(1);
|
|
1279
1434
|
}
|
|
1280
1435
|
spinner.succeed(`Found ${result.data?.length || 0} process instances`);
|
|
@@ -1282,20 +1437,20 @@ async function listProcessInstances(client, options = {}) {
|
|
|
1282
1437
|
renderOutput(instances, {
|
|
1283
1438
|
format: options.format,
|
|
1284
1439
|
pretty: () => {
|
|
1285
|
-
console.log(
|
|
1440
|
+
console.log(chalk4__default.default.blue("\n\u{1F504} Process Instances\n"));
|
|
1286
1441
|
for (const instance of instances) {
|
|
1287
|
-
console.log(` ${
|
|
1288
|
-
console.log(` ${
|
|
1289
|
-
console.log(` ${
|
|
1442
|
+
console.log(` ${chalk4__default.default.green("\u2022")} ${chalk4__default.default.bold(instance.id)}`);
|
|
1443
|
+
console.log(` ${chalk4__default.default.gray("Definition:")} ${instance.definitionId || "N/A"}`);
|
|
1444
|
+
console.log(` ${chalk4__default.default.gray("Business Key:")} ${instance.businessKey || "N/A"}`);
|
|
1290
1445
|
console.log(
|
|
1291
|
-
` ${
|
|
1446
|
+
` ${chalk4__default.default.gray("Status:")} ${instance.ended ? "Ended" : instance.suspended ? "Suspended" : "Active"}`
|
|
1292
1447
|
);
|
|
1293
1448
|
console.log();
|
|
1294
1449
|
}
|
|
1295
1450
|
}
|
|
1296
1451
|
});
|
|
1297
1452
|
} catch (error) {
|
|
1298
|
-
|
|
1453
|
+
exitWithCommandError3(spinner, "Failed to fetch process instances", error);
|
|
1299
1454
|
}
|
|
1300
1455
|
}
|
|
1301
1456
|
async function getProcessInstance(client, options) {
|
|
@@ -1305,19 +1460,19 @@ async function getProcessInstance(client, options) {
|
|
|
1305
1460
|
const result = await bpmClient.getProcessInstance(options.id);
|
|
1306
1461
|
if (result.error) {
|
|
1307
1462
|
spinner.fail("Failed to fetch process instance");
|
|
1308
|
-
console.error(
|
|
1463
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1309
1464
|
process.exit(1);
|
|
1310
1465
|
}
|
|
1311
1466
|
spinner.succeed("Process instance retrieved");
|
|
1312
1467
|
renderOutput(result.data, {
|
|
1313
1468
|
format: options.format,
|
|
1314
1469
|
pretty: () => {
|
|
1315
|
-
console.log(
|
|
1470
|
+
console.log(chalk4__default.default.blue("\n\u{1F4CA} Process Instance\n"));
|
|
1316
1471
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1317
1472
|
}
|
|
1318
1473
|
});
|
|
1319
1474
|
} catch (error) {
|
|
1320
|
-
|
|
1475
|
+
exitWithCommandError3(spinner, "Failed to fetch process instance", error);
|
|
1321
1476
|
}
|
|
1322
1477
|
}
|
|
1323
1478
|
async function getActivityInstanceTree(client, options) {
|
|
@@ -1327,19 +1482,19 @@ async function getActivityInstanceTree(client, options) {
|
|
|
1327
1482
|
const result = await bpmClient.getActivityInstanceTree(options.id);
|
|
1328
1483
|
if (result.error) {
|
|
1329
1484
|
spinner.fail("Failed to fetch activity instance tree");
|
|
1330
|
-
console.error(
|
|
1485
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1331
1486
|
process.exit(1);
|
|
1332
1487
|
}
|
|
1333
1488
|
spinner.succeed("Activity instance tree retrieved");
|
|
1334
1489
|
renderOutput(result.data, {
|
|
1335
1490
|
format: options.format,
|
|
1336
1491
|
pretty: () => {
|
|
1337
|
-
console.log(
|
|
1492
|
+
console.log(chalk4__default.default.blue("\n\u{1F333} Activity Instance Tree\n"));
|
|
1338
1493
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1339
1494
|
}
|
|
1340
1495
|
});
|
|
1341
1496
|
} catch (error) {
|
|
1342
|
-
|
|
1497
|
+
exitWithCommandError3(spinner, "Failed to fetch activity instance tree", error);
|
|
1343
1498
|
}
|
|
1344
1499
|
}
|
|
1345
1500
|
async function getActiveActivities(client, options) {
|
|
@@ -1349,7 +1504,7 @@ async function getActiveActivities(client, options) {
|
|
|
1349
1504
|
const result = await bpmClient.getActiveActivities(options.id);
|
|
1350
1505
|
if (result.error) {
|
|
1351
1506
|
spinner.fail("Failed to fetch active activities");
|
|
1352
|
-
console.error(
|
|
1507
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1353
1508
|
process.exit(1);
|
|
1354
1509
|
}
|
|
1355
1510
|
const activities = Array.isArray(result.data) ? result.data : [];
|
|
@@ -1357,12 +1512,12 @@ async function getActiveActivities(client, options) {
|
|
|
1357
1512
|
renderOutput(result.data, {
|
|
1358
1513
|
format: options.format,
|
|
1359
1514
|
pretty: () => {
|
|
1360
|
-
console.log(
|
|
1515
|
+
console.log(chalk4__default.default.blue("\n\u26A1 Active Activities\n"));
|
|
1361
1516
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1362
1517
|
}
|
|
1363
1518
|
});
|
|
1364
1519
|
} catch (error) {
|
|
1365
|
-
|
|
1520
|
+
exitWithCommandError3(spinner, "Failed to fetch active activities", error);
|
|
1366
1521
|
}
|
|
1367
1522
|
}
|
|
1368
1523
|
async function getRuntimeVariables(client, options) {
|
|
@@ -1372,19 +1527,19 @@ async function getRuntimeVariables(client, options) {
|
|
|
1372
1527
|
const result = await bpmClient.getRuntimeVariables(options.id);
|
|
1373
1528
|
if (result.error) {
|
|
1374
1529
|
spinner.fail("Failed to fetch runtime variables");
|
|
1375
|
-
console.error(
|
|
1530
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1376
1531
|
process.exit(1);
|
|
1377
1532
|
}
|
|
1378
1533
|
spinner.succeed("Runtime variables retrieved");
|
|
1379
1534
|
renderOutput(result.data, {
|
|
1380
1535
|
format: options.format,
|
|
1381
1536
|
pretty: () => {
|
|
1382
|
-
console.log(
|
|
1537
|
+
console.log(chalk4__default.default.blue("\n\u{1F9EE} Runtime Variables\n"));
|
|
1383
1538
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1384
1539
|
}
|
|
1385
1540
|
});
|
|
1386
1541
|
} catch (error) {
|
|
1387
|
-
|
|
1542
|
+
exitWithCommandError3(spinner, "Failed to fetch runtime variables", error);
|
|
1388
1543
|
}
|
|
1389
1544
|
}
|
|
1390
1545
|
async function getProcessVariables(client, options) {
|
|
@@ -1397,19 +1552,19 @@ async function getProcessVariables(client, options) {
|
|
|
1397
1552
|
});
|
|
1398
1553
|
if (result.error) {
|
|
1399
1554
|
spinner.fail("Failed to fetch process variables");
|
|
1400
|
-
console.error(
|
|
1555
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1401
1556
|
process.exit(1);
|
|
1402
1557
|
}
|
|
1403
1558
|
spinner.succeed(`Found ${result.data?.length || 0} variables`);
|
|
1404
1559
|
renderOutput(result.data || [], {
|
|
1405
1560
|
format: options.format,
|
|
1406
1561
|
pretty: () => {
|
|
1407
|
-
console.log(
|
|
1562
|
+
console.log(chalk4__default.default.blue("\n\u{1F9FE} Process Variables\n"));
|
|
1408
1563
|
console.log(JSON.stringify(result.data || [], null, 2));
|
|
1409
1564
|
}
|
|
1410
1565
|
});
|
|
1411
1566
|
} catch (error) {
|
|
1412
|
-
|
|
1567
|
+
exitWithCommandError3(spinner, "Failed to fetch process variables", error);
|
|
1413
1568
|
}
|
|
1414
1569
|
}
|
|
1415
1570
|
async function deleteProcessInstance(client, options) {
|
|
@@ -1421,7 +1576,7 @@ async function deleteProcessInstance(client, options) {
|
|
|
1421
1576
|
});
|
|
1422
1577
|
if (result.error) {
|
|
1423
1578
|
spinner.fail("Failed to delete process instance");
|
|
1424
|
-
console.error(
|
|
1579
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1425
1580
|
process.exit(1);
|
|
1426
1581
|
}
|
|
1427
1582
|
spinner.succeed("Process instance deleted");
|
|
@@ -1434,12 +1589,12 @@ async function deleteProcessInstance(client, options) {
|
|
|
1434
1589
|
{
|
|
1435
1590
|
format: options.format,
|
|
1436
1591
|
pretty: () => {
|
|
1437
|
-
console.log(
|
|
1592
|
+
console.log(chalk4__default.default.green(`Deleted process instance: ${options.id}`));
|
|
1438
1593
|
}
|
|
1439
1594
|
}
|
|
1440
1595
|
);
|
|
1441
1596
|
} catch (error) {
|
|
1442
|
-
|
|
1597
|
+
exitWithCommandError3(spinner, "Failed to delete process instance", error);
|
|
1443
1598
|
}
|
|
1444
1599
|
}
|
|
1445
1600
|
async function suspendProcessInstance(client, options) {
|
|
@@ -1449,7 +1604,7 @@ async function suspendProcessInstance(client, options) {
|
|
|
1449
1604
|
const result = await bpmClient.suspendProcessInstance(options.id);
|
|
1450
1605
|
if (result.error) {
|
|
1451
1606
|
spinner.fail("Failed to suspend process instance");
|
|
1452
|
-
console.error(
|
|
1607
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1453
1608
|
process.exit(1);
|
|
1454
1609
|
}
|
|
1455
1610
|
spinner.succeed("Process instance suspended");
|
|
@@ -1461,12 +1616,12 @@ async function suspendProcessInstance(client, options) {
|
|
|
1461
1616
|
{
|
|
1462
1617
|
format: options.format,
|
|
1463
1618
|
pretty: () => {
|
|
1464
|
-
console.log(
|
|
1619
|
+
console.log(chalk4__default.default.green(`Suspended process instance: ${options.id}`));
|
|
1465
1620
|
}
|
|
1466
1621
|
}
|
|
1467
1622
|
);
|
|
1468
1623
|
} catch (error) {
|
|
1469
|
-
|
|
1624
|
+
exitWithCommandError3(spinner, "Failed to suspend process instance", error);
|
|
1470
1625
|
}
|
|
1471
1626
|
}
|
|
1472
1627
|
async function activateProcessInstance(client, options) {
|
|
@@ -1476,7 +1631,7 @@ async function activateProcessInstance(client, options) {
|
|
|
1476
1631
|
const result = await bpmClient.activateProcessInstance(options.id);
|
|
1477
1632
|
if (result.error) {
|
|
1478
1633
|
spinner.fail("Failed to activate process instance");
|
|
1479
|
-
console.error(
|
|
1634
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1480
1635
|
process.exit(1);
|
|
1481
1636
|
}
|
|
1482
1637
|
spinner.succeed("Process instance activated");
|
|
@@ -1488,12 +1643,12 @@ async function activateProcessInstance(client, options) {
|
|
|
1488
1643
|
{
|
|
1489
1644
|
format: options.format,
|
|
1490
1645
|
pretty: () => {
|
|
1491
|
-
console.log(
|
|
1646
|
+
console.log(chalk4__default.default.green(`Activated process instance: ${options.id}`));
|
|
1492
1647
|
}
|
|
1493
1648
|
}
|
|
1494
1649
|
);
|
|
1495
1650
|
} catch (error) {
|
|
1496
|
-
|
|
1651
|
+
exitWithCommandError3(spinner, "Failed to activate process instance", error);
|
|
1497
1652
|
}
|
|
1498
1653
|
}
|
|
1499
1654
|
async function modifyProcessInstance(client, options) {
|
|
@@ -1508,7 +1663,7 @@ async function modifyProcessInstance(client, options) {
|
|
|
1508
1663
|
const result = await bpmClient.modifyProcessInstance(options.id, modification);
|
|
1509
1664
|
if (result.error) {
|
|
1510
1665
|
spinner.fail("Failed to modify process instance");
|
|
1511
|
-
console.error(
|
|
1666
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1512
1667
|
process.exit(1);
|
|
1513
1668
|
}
|
|
1514
1669
|
spinner.succeed("Process instance modified");
|
|
@@ -1521,12 +1676,12 @@ async function modifyProcessInstance(client, options) {
|
|
|
1521
1676
|
{
|
|
1522
1677
|
format: options.format,
|
|
1523
1678
|
pretty: () => {
|
|
1524
|
-
console.log(
|
|
1679
|
+
console.log(chalk4__default.default.green(`Modified process instance: ${options.id}`));
|
|
1525
1680
|
}
|
|
1526
1681
|
}
|
|
1527
1682
|
);
|
|
1528
1683
|
} catch (error) {
|
|
1529
|
-
|
|
1684
|
+
exitWithCommandError3(spinner, "Failed to modify process instance", error);
|
|
1530
1685
|
}
|
|
1531
1686
|
}
|
|
1532
1687
|
async function listTasks(client, options) {
|
|
@@ -1537,7 +1692,7 @@ async function listTasks(client, options) {
|
|
|
1537
1692
|
const result = await bpmClient.getTasks(params);
|
|
1538
1693
|
if (result.error) {
|
|
1539
1694
|
spinner.fail("Failed to fetch tasks");
|
|
1540
|
-
console.error(
|
|
1695
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1541
1696
|
process.exit(1);
|
|
1542
1697
|
}
|
|
1543
1698
|
spinner.succeed(`Found ${result.data?.length || 0} tasks`);
|
|
@@ -1545,19 +1700,19 @@ async function listTasks(client, options) {
|
|
|
1545
1700
|
renderOutput(tasks, {
|
|
1546
1701
|
format: options.format,
|
|
1547
1702
|
pretty: () => {
|
|
1548
|
-
console.log(
|
|
1703
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DD} Tasks\n"));
|
|
1549
1704
|
for (const task of tasks) {
|
|
1550
|
-
console.log(` ${
|
|
1551
|
-
console.log(` ${
|
|
1552
|
-
console.log(` ${
|
|
1553
|
-
console.log(` ${
|
|
1554
|
-
console.log(` ${
|
|
1705
|
+
console.log(` ${chalk4__default.default.green("\u2022")} ${chalk4__default.default.bold(task.name || task.id)}`);
|
|
1706
|
+
console.log(` ${chalk4__default.default.gray("ID:")} ${task.id}`);
|
|
1707
|
+
console.log(` ${chalk4__default.default.gray("Assignee:")} ${task.assignee || "Unassigned"}`);
|
|
1708
|
+
console.log(` ${chalk4__default.default.gray("Process Instance:")} ${task.processInstanceId || "N/A"}`);
|
|
1709
|
+
console.log(` ${chalk4__default.default.gray("Created:")} ${task.created || "N/A"}`);
|
|
1555
1710
|
console.log();
|
|
1556
1711
|
}
|
|
1557
1712
|
}
|
|
1558
1713
|
});
|
|
1559
1714
|
} catch (error) {
|
|
1560
|
-
|
|
1715
|
+
exitWithCommandError3(spinner, "Failed to fetch tasks", error);
|
|
1561
1716
|
}
|
|
1562
1717
|
}
|
|
1563
1718
|
async function getTask(client, options) {
|
|
@@ -1567,19 +1722,19 @@ async function getTask(client, options) {
|
|
|
1567
1722
|
const result = await bpmClient.getTask(options.id);
|
|
1568
1723
|
if (result.error) {
|
|
1569
1724
|
spinner.fail("Failed to fetch task");
|
|
1570
|
-
console.error(
|
|
1725
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1571
1726
|
process.exit(1);
|
|
1572
1727
|
}
|
|
1573
1728
|
spinner.succeed("Task retrieved");
|
|
1574
1729
|
renderOutput(result.data, {
|
|
1575
1730
|
format: options.format,
|
|
1576
1731
|
pretty: () => {
|
|
1577
|
-
console.log(
|
|
1732
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DD} Task\n"));
|
|
1578
1733
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1579
1734
|
}
|
|
1580
1735
|
});
|
|
1581
1736
|
} catch (error) {
|
|
1582
|
-
|
|
1737
|
+
exitWithCommandError3(spinner, "Failed to fetch task", error);
|
|
1583
1738
|
}
|
|
1584
1739
|
}
|
|
1585
1740
|
async function getTaskCount(client, options) {
|
|
@@ -1590,18 +1745,18 @@ async function getTaskCount(client, options) {
|
|
|
1590
1745
|
const result = await bpmClient.getTaskCount(params);
|
|
1591
1746
|
if (result.error) {
|
|
1592
1747
|
spinner.fail("Failed to fetch task count");
|
|
1593
|
-
console.error(
|
|
1748
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1594
1749
|
process.exit(1);
|
|
1595
1750
|
}
|
|
1596
1751
|
spinner.succeed("Task count retrieved");
|
|
1597
1752
|
renderOutput(result.data, {
|
|
1598
1753
|
format: options.format,
|
|
1599
1754
|
pretty: () => {
|
|
1600
|
-
console.log(
|
|
1755
|
+
console.log(chalk4__default.default.green(`Task count: ${result.data?.count ?? 0}`));
|
|
1601
1756
|
}
|
|
1602
1757
|
});
|
|
1603
1758
|
} catch (error) {
|
|
1604
|
-
|
|
1759
|
+
exitWithCommandError3(spinner, "Failed to fetch task count", error);
|
|
1605
1760
|
}
|
|
1606
1761
|
}
|
|
1607
1762
|
async function completeTask(client, options) {
|
|
@@ -1612,7 +1767,7 @@ async function completeTask(client, options) {
|
|
|
1612
1767
|
const result = await bpmClient.completeTask(options.id, variables);
|
|
1613
1768
|
if (result.error) {
|
|
1614
1769
|
spinner.fail("Failed to complete task");
|
|
1615
|
-
console.error(
|
|
1770
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1616
1771
|
process.exit(1);
|
|
1617
1772
|
}
|
|
1618
1773
|
spinner.succeed("Task completed");
|
|
@@ -1624,12 +1779,12 @@ async function completeTask(client, options) {
|
|
|
1624
1779
|
{
|
|
1625
1780
|
format: options.format,
|
|
1626
1781
|
pretty: () => {
|
|
1627
|
-
console.log(
|
|
1782
|
+
console.log(chalk4__default.default.green(`Completed task: ${options.id}`));
|
|
1628
1783
|
}
|
|
1629
1784
|
}
|
|
1630
1785
|
);
|
|
1631
1786
|
} catch (error) {
|
|
1632
|
-
|
|
1787
|
+
exitWithCommandError3(spinner, "Failed to complete task", error);
|
|
1633
1788
|
}
|
|
1634
1789
|
}
|
|
1635
1790
|
async function delegateTask(client, options) {
|
|
@@ -1639,7 +1794,7 @@ async function delegateTask(client, options) {
|
|
|
1639
1794
|
const result = await bpmClient.delegateTask(options.id, options.userId);
|
|
1640
1795
|
if (result.error) {
|
|
1641
1796
|
spinner.fail("Failed to delegate task");
|
|
1642
|
-
console.error(
|
|
1797
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1643
1798
|
process.exit(1);
|
|
1644
1799
|
}
|
|
1645
1800
|
spinner.succeed("Task delegated");
|
|
@@ -1652,12 +1807,12 @@ async function delegateTask(client, options) {
|
|
|
1652
1807
|
{
|
|
1653
1808
|
format: options.format,
|
|
1654
1809
|
pretty: () => {
|
|
1655
|
-
console.log(
|
|
1810
|
+
console.log(chalk4__default.default.green(`Delegated task ${options.id} to ${options.userId}`));
|
|
1656
1811
|
}
|
|
1657
1812
|
}
|
|
1658
1813
|
);
|
|
1659
1814
|
} catch (error) {
|
|
1660
|
-
|
|
1815
|
+
exitWithCommandError3(spinner, "Failed to delegate task", error);
|
|
1661
1816
|
}
|
|
1662
1817
|
}
|
|
1663
1818
|
async function getTaskForm(client, options) {
|
|
@@ -1667,19 +1822,19 @@ async function getTaskForm(client, options) {
|
|
|
1667
1822
|
const result = await bpmClient.getTaskForm(options.id);
|
|
1668
1823
|
if (result.error) {
|
|
1669
1824
|
spinner.fail("Failed to fetch task form");
|
|
1670
|
-
console.error(
|
|
1825
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1671
1826
|
process.exit(1);
|
|
1672
1827
|
}
|
|
1673
1828
|
spinner.succeed("Task form retrieved");
|
|
1674
1829
|
renderOutput(result.data, {
|
|
1675
1830
|
format: options.format,
|
|
1676
1831
|
pretty: () => {
|
|
1677
|
-
console.log(
|
|
1832
|
+
console.log(chalk4__default.default.blue("\n\u{1F9E9} Task Form\n"));
|
|
1678
1833
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1679
1834
|
}
|
|
1680
1835
|
});
|
|
1681
1836
|
} catch (error) {
|
|
1682
|
-
|
|
1837
|
+
exitWithCommandError3(spinner, "Failed to fetch task form", error);
|
|
1683
1838
|
}
|
|
1684
1839
|
}
|
|
1685
1840
|
async function getTaskFormSchema(client, options) {
|
|
@@ -1702,12 +1857,12 @@ async function getTaskFormSchema(client, options) {
|
|
|
1702
1857
|
renderOutput(result.data, {
|
|
1703
1858
|
format: options.format,
|
|
1704
1859
|
pretty: () => {
|
|
1705
|
-
console.log(
|
|
1860
|
+
console.log(chalk4__default.default.blue("\n\u{1F9E9} Task Form Schema\n"));
|
|
1706
1861
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1707
1862
|
}
|
|
1708
1863
|
});
|
|
1709
1864
|
} catch (error) {
|
|
1710
|
-
|
|
1865
|
+
exitWithCommandError3(spinner, "Failed to fetch task form schema", error);
|
|
1711
1866
|
}
|
|
1712
1867
|
}
|
|
1713
1868
|
async function getTaskFormVariables(client, options) {
|
|
@@ -1717,19 +1872,19 @@ async function getTaskFormVariables(client, options) {
|
|
|
1717
1872
|
const result = await bpmClient.getTaskFormVariables(options.id);
|
|
1718
1873
|
if (result.error) {
|
|
1719
1874
|
spinner.fail("Failed to fetch task form variables");
|
|
1720
|
-
console.error(
|
|
1875
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1721
1876
|
process.exit(1);
|
|
1722
1877
|
}
|
|
1723
1878
|
spinner.succeed("Task form variables retrieved");
|
|
1724
1879
|
renderOutput(result.data, {
|
|
1725
1880
|
format: options.format,
|
|
1726
1881
|
pretty: () => {
|
|
1727
|
-
console.log(
|
|
1882
|
+
console.log(chalk4__default.default.blue("\n\u{1F9EE} Task Form Variables\n"));
|
|
1728
1883
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1729
1884
|
}
|
|
1730
1885
|
});
|
|
1731
1886
|
} catch (error) {
|
|
1732
|
-
|
|
1887
|
+
exitWithCommandError3(spinner, "Failed to fetch task form variables", error);
|
|
1733
1888
|
}
|
|
1734
1889
|
}
|
|
1735
1890
|
async function getTaskRenderedForm(client, options) {
|
|
@@ -1739,19 +1894,19 @@ async function getTaskRenderedForm(client, options) {
|
|
|
1739
1894
|
const result = await bpmClient.getTaskRenderedForm(options.id);
|
|
1740
1895
|
if (result.error) {
|
|
1741
1896
|
spinner.fail("Failed to fetch rendered task form");
|
|
1742
|
-
console.error(
|
|
1897
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1743
1898
|
process.exit(1);
|
|
1744
1899
|
}
|
|
1745
1900
|
spinner.succeed("Rendered task form retrieved");
|
|
1746
1901
|
renderOutput(result.data, {
|
|
1747
1902
|
format: options.format,
|
|
1748
1903
|
pretty: () => {
|
|
1749
|
-
console.log(
|
|
1904
|
+
console.log(chalk4__default.default.blue("\n\u{1F9FE} Rendered Task Form\n"));
|
|
1750
1905
|
console.log(result.data || "");
|
|
1751
1906
|
}
|
|
1752
1907
|
});
|
|
1753
1908
|
} catch (error) {
|
|
1754
|
-
|
|
1909
|
+
exitWithCommandError3(spinner, "Failed to fetch rendered task form", error);
|
|
1755
1910
|
}
|
|
1756
1911
|
}
|
|
1757
1912
|
async function getTaskDeployedForm(client, options) {
|
|
@@ -1761,19 +1916,19 @@ async function getTaskDeployedForm(client, options) {
|
|
|
1761
1916
|
const result = await bpmClient.getTaskDeployedForm(options.id);
|
|
1762
1917
|
if (result.error) {
|
|
1763
1918
|
spinner.fail("Failed to fetch deployed task form");
|
|
1764
|
-
console.error(
|
|
1919
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1765
1920
|
process.exit(1);
|
|
1766
1921
|
}
|
|
1767
1922
|
spinner.succeed("Deployed task form retrieved");
|
|
1768
1923
|
renderOutput(result.data, {
|
|
1769
1924
|
format: options.format,
|
|
1770
1925
|
pretty: () => {
|
|
1771
|
-
console.log(
|
|
1926
|
+
console.log(chalk4__default.default.blue("\n\u{1F9FE} Deployed Task Form\n"));
|
|
1772
1927
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1773
1928
|
}
|
|
1774
1929
|
});
|
|
1775
1930
|
} catch (error) {
|
|
1776
|
-
|
|
1931
|
+
exitWithCommandError3(spinner, "Failed to fetch deployed task form", error);
|
|
1777
1932
|
}
|
|
1778
1933
|
}
|
|
1779
1934
|
async function getStartFormInfo(client, options) {
|
|
@@ -1793,12 +1948,12 @@ async function getStartFormInfo(client, options) {
|
|
|
1793
1948
|
renderOutput(result.data, {
|
|
1794
1949
|
format: options.format,
|
|
1795
1950
|
pretty: () => {
|
|
1796
|
-
console.log(
|
|
1951
|
+
console.log(chalk4__default.default.blue("\n\u{1F680} Start Form Info\n"));
|
|
1797
1952
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1798
1953
|
}
|
|
1799
1954
|
});
|
|
1800
1955
|
} catch (error) {
|
|
1801
|
-
|
|
1956
|
+
exitWithCommandError3(spinner, "Failed to fetch start form info", error);
|
|
1802
1957
|
}
|
|
1803
1958
|
}
|
|
1804
1959
|
async function getStartFormVariables(client, options) {
|
|
@@ -1818,12 +1973,12 @@ async function getStartFormVariables(client, options) {
|
|
|
1818
1973
|
renderOutput(result.data, {
|
|
1819
1974
|
format: options.format,
|
|
1820
1975
|
pretty: () => {
|
|
1821
|
-
console.log(
|
|
1976
|
+
console.log(chalk4__default.default.blue("\n\u{1F680} Start Form Variables\n"));
|
|
1822
1977
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1823
1978
|
}
|
|
1824
1979
|
});
|
|
1825
1980
|
} catch (error) {
|
|
1826
|
-
|
|
1981
|
+
exitWithCommandError3(spinner, "Failed to fetch start form variables", error);
|
|
1827
1982
|
}
|
|
1828
1983
|
}
|
|
1829
1984
|
async function getDeployedStartForm(client, options) {
|
|
@@ -1843,12 +1998,12 @@ async function getDeployedStartForm(client, options) {
|
|
|
1843
1998
|
renderOutput(result.data, {
|
|
1844
1999
|
format: options.format,
|
|
1845
2000
|
pretty: () => {
|
|
1846
|
-
console.log(
|
|
2001
|
+
console.log(chalk4__default.default.blue("\n\u{1F680} Deployed Start Form\n"));
|
|
1847
2002
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1848
2003
|
}
|
|
1849
2004
|
});
|
|
1850
2005
|
} catch (error) {
|
|
1851
|
-
|
|
2006
|
+
exitWithCommandError3(spinner, "Failed to fetch deployed start form", error);
|
|
1852
2007
|
}
|
|
1853
2008
|
}
|
|
1854
2009
|
async function listHistoryTasks(client, options = {}) {
|
|
@@ -1859,7 +2014,7 @@ async function listHistoryTasks(client, options = {}) {
|
|
|
1859
2014
|
const result = await bpmClient.getHistoryTasks(params);
|
|
1860
2015
|
if (result.error) {
|
|
1861
2016
|
spinner.fail("Failed to fetch history tasks");
|
|
1862
|
-
console.error(
|
|
2017
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1863
2018
|
process.exit(1);
|
|
1864
2019
|
}
|
|
1865
2020
|
const tasks = result.data || [];
|
|
@@ -1867,12 +2022,12 @@ async function listHistoryTasks(client, options = {}) {
|
|
|
1867
2022
|
renderOutput(tasks, {
|
|
1868
2023
|
format: options.format,
|
|
1869
2024
|
pretty: () => {
|
|
1870
|
-
console.log(
|
|
2025
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} History Tasks\n"));
|
|
1871
2026
|
console.log(JSON.stringify(tasks, null, 2));
|
|
1872
2027
|
}
|
|
1873
2028
|
});
|
|
1874
2029
|
} catch (error) {
|
|
1875
|
-
|
|
2030
|
+
exitWithCommandError3(spinner, "Failed to fetch history tasks", error);
|
|
1876
2031
|
}
|
|
1877
2032
|
}
|
|
1878
2033
|
async function getHistoryTaskCount(client, options = {}) {
|
|
@@ -1883,18 +2038,18 @@ async function getHistoryTaskCount(client, options = {}) {
|
|
|
1883
2038
|
const result = await bpmClient.getHistoryTaskCount(params);
|
|
1884
2039
|
if (result.error) {
|
|
1885
2040
|
spinner.fail("Failed to fetch history task count");
|
|
1886
|
-
console.error(
|
|
2041
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1887
2042
|
process.exit(1);
|
|
1888
2043
|
}
|
|
1889
2044
|
spinner.succeed("History task count retrieved");
|
|
1890
2045
|
renderOutput(result.data, {
|
|
1891
2046
|
format: options.format,
|
|
1892
2047
|
pretty: () => {
|
|
1893
|
-
console.log(
|
|
2048
|
+
console.log(chalk4__default.default.green(`History task count: ${result.data?.count ?? 0}`));
|
|
1894
2049
|
}
|
|
1895
2050
|
});
|
|
1896
2051
|
} catch (error) {
|
|
1897
|
-
|
|
2052
|
+
exitWithCommandError3(spinner, "Failed to fetch history task count", error);
|
|
1898
2053
|
}
|
|
1899
2054
|
}
|
|
1900
2055
|
async function listHistoryProcessInstances(client, options = {}) {
|
|
@@ -1905,7 +2060,7 @@ async function listHistoryProcessInstances(client, options = {}) {
|
|
|
1905
2060
|
const result = await bpmClient.getHistoryProcessInstances(params);
|
|
1906
2061
|
if (result.error) {
|
|
1907
2062
|
spinner.fail("Failed to fetch history process instances");
|
|
1908
|
-
console.error(
|
|
2063
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1909
2064
|
process.exit(1);
|
|
1910
2065
|
}
|
|
1911
2066
|
const instances = result.data || [];
|
|
@@ -1913,12 +2068,12 @@ async function listHistoryProcessInstances(client, options = {}) {
|
|
|
1913
2068
|
renderOutput(instances, {
|
|
1914
2069
|
format: options.format,
|
|
1915
2070
|
pretty: () => {
|
|
1916
|
-
console.log(
|
|
2071
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} History Process Instances\n"));
|
|
1917
2072
|
console.log(JSON.stringify(instances, null, 2));
|
|
1918
2073
|
}
|
|
1919
2074
|
});
|
|
1920
2075
|
} catch (error) {
|
|
1921
|
-
|
|
2076
|
+
exitWithCommandError3(spinner, "Failed to fetch history process instances", error);
|
|
1922
2077
|
}
|
|
1923
2078
|
}
|
|
1924
2079
|
async function getHistoryProcessInstanceCount(client, options = {}) {
|
|
@@ -1929,18 +2084,18 @@ async function getHistoryProcessInstanceCount(client, options = {}) {
|
|
|
1929
2084
|
const result = await bpmClient.getHistoryProcessInstanceCount(params);
|
|
1930
2085
|
if (result.error) {
|
|
1931
2086
|
spinner.fail("Failed to fetch history process instance count");
|
|
1932
|
-
console.error(
|
|
2087
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1933
2088
|
process.exit(1);
|
|
1934
2089
|
}
|
|
1935
2090
|
spinner.succeed("History process instance count retrieved");
|
|
1936
2091
|
renderOutput(result.data, {
|
|
1937
2092
|
format: options.format,
|
|
1938
2093
|
pretty: () => {
|
|
1939
|
-
console.log(
|
|
2094
|
+
console.log(chalk4__default.default.green(`History process instance count: ${result.data?.count ?? 0}`));
|
|
1940
2095
|
}
|
|
1941
2096
|
});
|
|
1942
2097
|
} catch (error) {
|
|
1943
|
-
|
|
2098
|
+
exitWithCommandError3(spinner, "Failed to fetch history process instance count", error);
|
|
1944
2099
|
}
|
|
1945
2100
|
}
|
|
1946
2101
|
async function getHistoryProcessInstance(client, options) {
|
|
@@ -1950,19 +2105,19 @@ async function getHistoryProcessInstance(client, options) {
|
|
|
1950
2105
|
const result = await bpmClient.getHistoryProcessInstance(options.id);
|
|
1951
2106
|
if (result.error) {
|
|
1952
2107
|
spinner.fail("Failed to fetch history process instance");
|
|
1953
|
-
console.error(
|
|
2108
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1954
2109
|
process.exit(1);
|
|
1955
2110
|
}
|
|
1956
2111
|
spinner.succeed("History process instance retrieved");
|
|
1957
2112
|
renderOutput(result.data, {
|
|
1958
2113
|
format: options.format,
|
|
1959
2114
|
pretty: () => {
|
|
1960
|
-
console.log(
|
|
2115
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} History Process Instance\n"));
|
|
1961
2116
|
console.log(JSON.stringify(result.data, null, 2));
|
|
1962
2117
|
}
|
|
1963
2118
|
});
|
|
1964
2119
|
} catch (error) {
|
|
1965
|
-
|
|
2120
|
+
exitWithCommandError3(spinner, "Failed to fetch history process instance", error);
|
|
1966
2121
|
}
|
|
1967
2122
|
}
|
|
1968
2123
|
async function listHistoryActivityInstances(client, options = {}) {
|
|
@@ -1973,7 +2128,7 @@ async function listHistoryActivityInstances(client, options = {}) {
|
|
|
1973
2128
|
const result = await bpmClient.getHistoryActivityInstances(params);
|
|
1974
2129
|
if (result.error) {
|
|
1975
2130
|
spinner.fail("Failed to fetch history activity instances");
|
|
1976
|
-
console.error(
|
|
2131
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
1977
2132
|
process.exit(1);
|
|
1978
2133
|
}
|
|
1979
2134
|
const activities = result.data || [];
|
|
@@ -1981,12 +2136,12 @@ async function listHistoryActivityInstances(client, options = {}) {
|
|
|
1981
2136
|
renderOutput(activities, {
|
|
1982
2137
|
format: options.format,
|
|
1983
2138
|
pretty: () => {
|
|
1984
|
-
console.log(
|
|
2139
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} History Activity Instances\n"));
|
|
1985
2140
|
console.log(JSON.stringify(activities, null, 2));
|
|
1986
2141
|
}
|
|
1987
2142
|
});
|
|
1988
2143
|
} catch (error) {
|
|
1989
|
-
|
|
2144
|
+
exitWithCommandError3(spinner, "Failed to fetch history activity instances", error);
|
|
1990
2145
|
}
|
|
1991
2146
|
}
|
|
1992
2147
|
async function listHistoryVariableInstances(client, options = {}) {
|
|
@@ -1997,7 +2152,7 @@ async function listHistoryVariableInstances(client, options = {}) {
|
|
|
1997
2152
|
const result = await bpmClient.getHistoryVariableInstances(params);
|
|
1998
2153
|
if (result.error) {
|
|
1999
2154
|
spinner.fail("Failed to fetch history variable instances");
|
|
2000
|
-
console.error(
|
|
2155
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2001
2156
|
process.exit(1);
|
|
2002
2157
|
}
|
|
2003
2158
|
const variables = result.data || [];
|
|
@@ -2005,12 +2160,12 @@ async function listHistoryVariableInstances(client, options = {}) {
|
|
|
2005
2160
|
renderOutput(variables, {
|
|
2006
2161
|
format: options.format,
|
|
2007
2162
|
pretty: () => {
|
|
2008
|
-
console.log(
|
|
2163
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} History Variable Instances\n"));
|
|
2009
2164
|
console.log(JSON.stringify(variables, null, 2));
|
|
2010
2165
|
}
|
|
2011
2166
|
});
|
|
2012
2167
|
} catch (error) {
|
|
2013
|
-
|
|
2168
|
+
exitWithCommandError3(spinner, "Failed to fetch history variable instances", error);
|
|
2014
2169
|
}
|
|
2015
2170
|
}
|
|
2016
2171
|
async function listUserOperationLogs(client, options = {}) {
|
|
@@ -2021,7 +2176,7 @@ async function listUserOperationLogs(client, options = {}) {
|
|
|
2021
2176
|
const result = await bpmClient.getUserOperationLogs(params);
|
|
2022
2177
|
if (result.error) {
|
|
2023
2178
|
spinner.fail("Failed to fetch user operation logs");
|
|
2024
|
-
console.error(
|
|
2179
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2025
2180
|
process.exit(1);
|
|
2026
2181
|
}
|
|
2027
2182
|
const logs = result.data || [];
|
|
@@ -2029,12 +2184,12 @@ async function listUserOperationLogs(client, options = {}) {
|
|
|
2029
2184
|
renderOutput(logs, {
|
|
2030
2185
|
format: options.format,
|
|
2031
2186
|
pretty: () => {
|
|
2032
|
-
console.log(
|
|
2187
|
+
console.log(chalk4__default.default.blue("\n\u{1F4DA} User Operation Logs\n"));
|
|
2033
2188
|
console.log(JSON.stringify(logs, null, 2));
|
|
2034
2189
|
}
|
|
2035
2190
|
});
|
|
2036
2191
|
} catch (error) {
|
|
2037
|
-
|
|
2192
|
+
exitWithCommandError3(spinner, "Failed to fetch user operation logs", error);
|
|
2038
2193
|
}
|
|
2039
2194
|
}
|
|
2040
2195
|
async function deleteHistoryProcessInstance(client, options) {
|
|
@@ -2044,7 +2199,7 @@ async function deleteHistoryProcessInstance(client, options) {
|
|
|
2044
2199
|
const result = await bpmClient.deleteHistoryProcessInstance(options.id);
|
|
2045
2200
|
if (result.error) {
|
|
2046
2201
|
spinner.fail("Failed to delete history process instance");
|
|
2047
|
-
console.error(
|
|
2202
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2048
2203
|
process.exit(1);
|
|
2049
2204
|
}
|
|
2050
2205
|
spinner.succeed("History process instance deleted");
|
|
@@ -2056,12 +2211,12 @@ async function deleteHistoryProcessInstance(client, options) {
|
|
|
2056
2211
|
{
|
|
2057
2212
|
format: options.format,
|
|
2058
2213
|
pretty: () => {
|
|
2059
|
-
console.log(
|
|
2214
|
+
console.log(chalk4__default.default.green(`Deleted history process instance: ${options.id}`));
|
|
2060
2215
|
}
|
|
2061
2216
|
}
|
|
2062
2217
|
);
|
|
2063
2218
|
} catch (error) {
|
|
2064
|
-
|
|
2219
|
+
exitWithCommandError3(spinner, "Failed to delete history process instance", error);
|
|
2065
2220
|
}
|
|
2066
2221
|
}
|
|
2067
2222
|
async function listRoles(client, options = {}) {
|
|
@@ -2071,7 +2226,7 @@ async function listRoles(client, options = {}) {
|
|
|
2071
2226
|
const result = await bpmClient.getRoles();
|
|
2072
2227
|
if (result.error) {
|
|
2073
2228
|
spinner.fail("Failed to fetch roles");
|
|
2074
|
-
console.error(
|
|
2229
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2075
2230
|
process.exit(1);
|
|
2076
2231
|
}
|
|
2077
2232
|
const roles = result.data || [];
|
|
@@ -2079,12 +2234,12 @@ async function listRoles(client, options = {}) {
|
|
|
2079
2234
|
renderOutput(roles, {
|
|
2080
2235
|
format: options.format,
|
|
2081
2236
|
pretty: () => {
|
|
2082
|
-
console.log(
|
|
2237
|
+
console.log(chalk4__default.default.blue("\n\u{1F465} Roles\n"));
|
|
2083
2238
|
console.log(JSON.stringify(roles, null, 2));
|
|
2084
2239
|
}
|
|
2085
2240
|
});
|
|
2086
2241
|
} catch (error) {
|
|
2087
|
-
|
|
2242
|
+
exitWithCommandError3(spinner, "Failed to fetch roles", error);
|
|
2088
2243
|
}
|
|
2089
2244
|
}
|
|
2090
2245
|
async function getUserRoles(client, options) {
|
|
@@ -2094,7 +2249,7 @@ async function getUserRoles(client, options) {
|
|
|
2094
2249
|
const result = await bpmClient.getUserRoles(options.userId);
|
|
2095
2250
|
if (result.error) {
|
|
2096
2251
|
spinner.fail("Failed to fetch user roles");
|
|
2097
|
-
console.error(
|
|
2252
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2098
2253
|
process.exit(1);
|
|
2099
2254
|
}
|
|
2100
2255
|
const roles = result.data || [];
|
|
@@ -2102,17 +2257,19 @@ async function getUserRoles(client, options) {
|
|
|
2102
2257
|
renderOutput(roles, {
|
|
2103
2258
|
format: options.format,
|
|
2104
2259
|
pretty: () => {
|
|
2105
|
-
console.log(
|
|
2260
|
+
console.log(chalk4__default.default.blue(`
|
|
2106
2261
|
\u{1F464} User Roles: ${options.userId}
|
|
2107
2262
|
`));
|
|
2108
2263
|
console.log(JSON.stringify(roles, null, 2));
|
|
2109
2264
|
}
|
|
2110
2265
|
});
|
|
2111
2266
|
} catch (error) {
|
|
2112
|
-
|
|
2267
|
+
exitWithCommandError3(spinner, "Failed to fetch user roles", error);
|
|
2113
2268
|
}
|
|
2114
2269
|
}
|
|
2115
|
-
|
|
2270
|
+
var WORKFLOW_LIST_PATH = "/api/proxy/builtin/platform/workflow/openapi/apps";
|
|
2271
|
+
var WORKFLOW_GET_PATH = (workflowId) => `/api/proxy/builtin/platform/workflow/openapi/apps/${encodeURIComponent(workflowId)}/dsl`;
|
|
2272
|
+
function resolveInputSource4(input) {
|
|
2116
2273
|
if (!input.startsWith("@")) {
|
|
2117
2274
|
return input;
|
|
2118
2275
|
}
|
|
@@ -2123,7 +2280,7 @@ function resolveInputSource3(input) {
|
|
|
2123
2280
|
return fs.readFileSync(filePath, "utf8");
|
|
2124
2281
|
}
|
|
2125
2282
|
function parseJsonInput3(input, label) {
|
|
2126
|
-
const source =
|
|
2283
|
+
const source = resolveInputSource4(input).trim();
|
|
2127
2284
|
if (!source) {
|
|
2128
2285
|
throw new Error(`${label} is required.`);
|
|
2129
2286
|
}
|
|
@@ -2137,6 +2294,151 @@ function parseJsonInput3(input, label) {
|
|
|
2137
2294
|
function isPlainObject4(value) {
|
|
2138
2295
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
2139
2296
|
}
|
|
2297
|
+
function parseWorkflowTracing(value) {
|
|
2298
|
+
if (!value) {
|
|
2299
|
+
return null;
|
|
2300
|
+
}
|
|
2301
|
+
if (isPlainObject4(value)) {
|
|
2302
|
+
return value;
|
|
2303
|
+
}
|
|
2304
|
+
if (typeof value !== "string") {
|
|
2305
|
+
return null;
|
|
2306
|
+
}
|
|
2307
|
+
try {
|
|
2308
|
+
const parsed = JSON.parse(value);
|
|
2309
|
+
return isPlainObject4(parsed) ? parsed : null;
|
|
2310
|
+
} catch {
|
|
2311
|
+
return null;
|
|
2312
|
+
}
|
|
2313
|
+
}
|
|
2314
|
+
function getRunnableName(summary) {
|
|
2315
|
+
const tracing = parseWorkflowTracing(summary.tracing);
|
|
2316
|
+
const baseName = tracing?.base_name;
|
|
2317
|
+
if (typeof baseName === "string" && baseName.trim()) {
|
|
2318
|
+
return baseName.trim();
|
|
2319
|
+
}
|
|
2320
|
+
return null;
|
|
2321
|
+
}
|
|
2322
|
+
function normalizeWorkflowSummary(summary) {
|
|
2323
|
+
return {
|
|
2324
|
+
...summary,
|
|
2325
|
+
id: typeof summary.id === "string" ? summary.id : "",
|
|
2326
|
+
name: typeof summary.name === "string" ? summary.name : "",
|
|
2327
|
+
runnable_name: getRunnableName(summary),
|
|
2328
|
+
description: typeof summary.description === "string" ? summary.description : null,
|
|
2329
|
+
mode: typeof summary.mode === "string" ? summary.mode : null
|
|
2330
|
+
};
|
|
2331
|
+
}
|
|
2332
|
+
function extractWorkflowInputVariables(dsl) {
|
|
2333
|
+
if (!isPlainObject4(dsl)) {
|
|
2334
|
+
return [];
|
|
2335
|
+
}
|
|
2336
|
+
const candidateNodeSets = [];
|
|
2337
|
+
if (Array.isArray(dsl.nodes)) {
|
|
2338
|
+
candidateNodeSets.push(dsl.nodes);
|
|
2339
|
+
}
|
|
2340
|
+
if (isPlainObject4(dsl.graph) && Array.isArray(dsl.graph.nodes)) {
|
|
2341
|
+
candidateNodeSets.push(dsl.graph.nodes);
|
|
2342
|
+
}
|
|
2343
|
+
const variables = [];
|
|
2344
|
+
for (const nodeSet of candidateNodeSets) {
|
|
2345
|
+
for (const node of nodeSet) {
|
|
2346
|
+
if (!isPlainObject4(node) || !isPlainObject4(node.data)) {
|
|
2347
|
+
continue;
|
|
2348
|
+
}
|
|
2349
|
+
const nodeData = node.data;
|
|
2350
|
+
if (nodeData.type !== "start" || !Array.isArray(nodeData.variables)) {
|
|
2351
|
+
continue;
|
|
2352
|
+
}
|
|
2353
|
+
for (const variable of nodeData.variables) {
|
|
2354
|
+
if (!isPlainObject4(variable) || typeof variable.variable !== "string") {
|
|
2355
|
+
continue;
|
|
2356
|
+
}
|
|
2357
|
+
variables.push({
|
|
2358
|
+
...variable,
|
|
2359
|
+
variable: variable.variable,
|
|
2360
|
+
label: typeof variable.label === "string" ? variable.label : void 0,
|
|
2361
|
+
required: typeof variable.required === "boolean" ? variable.required : void 0,
|
|
2362
|
+
type: typeof variable.type === "string" ? variable.type : void 0
|
|
2363
|
+
});
|
|
2364
|
+
}
|
|
2365
|
+
}
|
|
2366
|
+
}
|
|
2367
|
+
return variables;
|
|
2368
|
+
}
|
|
2369
|
+
function normalizeWorkflowDefinition(definition) {
|
|
2370
|
+
return {
|
|
2371
|
+
...definition,
|
|
2372
|
+
workflow_id: typeof definition.workflow_id === "string" ? definition.workflow_id : "",
|
|
2373
|
+
app_id: typeof definition.app_id === "string" ? definition.app_id : "",
|
|
2374
|
+
version: typeof definition.version === "string" ? definition.version : void 0,
|
|
2375
|
+
name: typeof definition.name === "string" ? definition.name : "",
|
|
2376
|
+
dsl: isPlainObject4(definition.dsl) ? definition.dsl : void 0,
|
|
2377
|
+
context: typeof definition.context === "string" ? definition.context : void 0,
|
|
2378
|
+
input_variables: extractWorkflowInputVariables(definition.dsl)
|
|
2379
|
+
};
|
|
2380
|
+
}
|
|
2381
|
+
function invalidResponse(status, message) {
|
|
2382
|
+
return {
|
|
2383
|
+
data: null,
|
|
2384
|
+
error: {
|
|
2385
|
+
status,
|
|
2386
|
+
message
|
|
2387
|
+
},
|
|
2388
|
+
status
|
|
2389
|
+
};
|
|
2390
|
+
}
|
|
2391
|
+
function createWorkflowService(client) {
|
|
2392
|
+
return {
|
|
2393
|
+
async list(params = {}) {
|
|
2394
|
+
const response = await client.http.request({
|
|
2395
|
+
url: WORKFLOW_LIST_PATH,
|
|
2396
|
+
method: "GET",
|
|
2397
|
+
params: {
|
|
2398
|
+
page: params.page ?? 1,
|
|
2399
|
+
limit: params.limit ?? 20,
|
|
2400
|
+
mode: params.mode ?? "workflow"
|
|
2401
|
+
}
|
|
2402
|
+
});
|
|
2403
|
+
if (!response.data || !Array.isArray(response.data.data)) {
|
|
2404
|
+
return invalidResponse(
|
|
2405
|
+
response.status,
|
|
2406
|
+
response.error?.message || "Invalid workflow list response structure"
|
|
2407
|
+
);
|
|
2408
|
+
}
|
|
2409
|
+
return {
|
|
2410
|
+
...response,
|
|
2411
|
+
data: {
|
|
2412
|
+
...response.data,
|
|
2413
|
+
page: typeof response.data.page === "number" ? response.data.page : params.page ?? 1,
|
|
2414
|
+
limit: typeof response.data.limit === "number" ? response.data.limit : params.limit ?? 20,
|
|
2415
|
+
total: typeof response.data.total === "number" ? response.data.total : response.data.data.length,
|
|
2416
|
+
has_more: typeof response.data.has_more === "boolean" ? response.data.has_more : false,
|
|
2417
|
+
data: response.data.data.map(normalizeWorkflowSummary)
|
|
2418
|
+
}
|
|
2419
|
+
};
|
|
2420
|
+
},
|
|
2421
|
+
async get(workflowId) {
|
|
2422
|
+
if (!workflowId) {
|
|
2423
|
+
return invalidResponse(400, "workflowId is required");
|
|
2424
|
+
}
|
|
2425
|
+
const response = await client.http.request({
|
|
2426
|
+
url: WORKFLOW_GET_PATH(workflowId),
|
|
2427
|
+
method: "GET"
|
|
2428
|
+
});
|
|
2429
|
+
if (!response.data || !isPlainObject4(response.data)) {
|
|
2430
|
+
return invalidResponse(
|
|
2431
|
+
response.status,
|
|
2432
|
+
response.error?.message || "Invalid workflow definition response structure"
|
|
2433
|
+
);
|
|
2434
|
+
}
|
|
2435
|
+
return {
|
|
2436
|
+
...response,
|
|
2437
|
+
data: normalizeWorkflowDefinition(response.data)
|
|
2438
|
+
};
|
|
2439
|
+
}
|
|
2440
|
+
};
|
|
2441
|
+
}
|
|
2140
2442
|
function loadOptionalJsonObjectInput3(input, label) {
|
|
2141
2443
|
if (!input) {
|
|
2142
2444
|
return {};
|
|
@@ -2157,11 +2459,11 @@ function loadOptionalJsonArrayInput(input, label) {
|
|
|
2157
2459
|
}
|
|
2158
2460
|
return value;
|
|
2159
2461
|
}
|
|
2160
|
-
function
|
|
2462
|
+
function exitWithCommandError4(spinner, failureMessage, error) {
|
|
2161
2463
|
spinner.fail(failureMessage);
|
|
2162
2464
|
const details = error instanceof Error ? error.message : String(error);
|
|
2163
2465
|
if (details) {
|
|
2164
|
-
console.error(
|
|
2466
|
+
console.error(chalk4__default.default.red(details));
|
|
2165
2467
|
}
|
|
2166
2468
|
process.exit(1);
|
|
2167
2469
|
}
|
|
@@ -2196,26 +2498,148 @@ async function runWorkflow(client, options) {
|
|
|
2196
2498
|
const result = await workflowClient.run(options.name, request);
|
|
2197
2499
|
if (result.error) {
|
|
2198
2500
|
spinner.fail("Failed to run workflow");
|
|
2199
|
-
console.error(
|
|
2501
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2200
2502
|
process.exit(1);
|
|
2201
2503
|
}
|
|
2202
2504
|
spinner.succeed("Workflow completed");
|
|
2203
2505
|
renderOutput(result.data, {
|
|
2204
2506
|
format: options.format,
|
|
2205
2507
|
pretty: () => {
|
|
2206
|
-
console.log(
|
|
2508
|
+
console.log(chalk4__default.default.blue("\n\u26A1 Workflow Run\n"));
|
|
2207
2509
|
console.log(JSON.stringify(result.data, null, 2));
|
|
2208
2510
|
}
|
|
2209
2511
|
});
|
|
2210
2512
|
} catch (error) {
|
|
2211
|
-
|
|
2513
|
+
exitWithCommandError4(spinner, "Failed to run workflow", error);
|
|
2212
2514
|
}
|
|
2213
2515
|
}
|
|
2214
|
-
function
|
|
2516
|
+
async function listWorkflows(client, options = {}) {
|
|
2517
|
+
const spinner = createSpinner("Fetching workflows...", options.format);
|
|
2518
|
+
try {
|
|
2519
|
+
const workflowService = createWorkflowService(client);
|
|
2520
|
+
const result = await workflowService.list({
|
|
2521
|
+
page: options.page,
|
|
2522
|
+
limit: options.limit,
|
|
2523
|
+
mode: options.mode
|
|
2524
|
+
});
|
|
2525
|
+
if (result.error) {
|
|
2526
|
+
spinner.fail("Failed to fetch workflows");
|
|
2527
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2528
|
+
process.exit(1);
|
|
2529
|
+
}
|
|
2530
|
+
const payload = result.data;
|
|
2531
|
+
const workflows = payload?.data || [];
|
|
2532
|
+
spinner.succeed(`Found ${workflows.length} workflow${workflows.length === 1 ? "" : "s"}`);
|
|
2533
|
+
renderOutput(payload, {
|
|
2534
|
+
format: options.format,
|
|
2535
|
+
tableRows: workflows.map((workflow) => ({
|
|
2536
|
+
id: workflow.id,
|
|
2537
|
+
runnableName: workflow.runnable_name,
|
|
2538
|
+
platformName: workflow.name,
|
|
2539
|
+
mode: workflow.mode,
|
|
2540
|
+
description: workflow.description
|
|
2541
|
+
})),
|
|
2542
|
+
csvRows: workflows.map((workflow) => ({
|
|
2543
|
+
id: workflow.id,
|
|
2544
|
+
runnableName: workflow.runnable_name,
|
|
2545
|
+
platformName: workflow.name,
|
|
2546
|
+
mode: workflow.mode,
|
|
2547
|
+
description: workflow.description
|
|
2548
|
+
})),
|
|
2549
|
+
ndjsonItems: workflows,
|
|
2550
|
+
pretty: () => {
|
|
2551
|
+
console.log(chalk4__default.default.blue("\nWorkflows\n"));
|
|
2552
|
+
if (workflows.length === 0) {
|
|
2553
|
+
console.log(chalk4__default.default.gray("No workflows found."));
|
|
2554
|
+
return;
|
|
2555
|
+
}
|
|
2556
|
+
for (const workflow of workflows) {
|
|
2557
|
+
console.log(`${chalk4__default.default.green("\u2022")} ${chalk4__default.default.bold(workflow.runnable_name || workflow.name)}`);
|
|
2558
|
+
console.log(` ${chalk4__default.default.gray("ID:")} ${workflow.id}`);
|
|
2559
|
+
console.log(` ${chalk4__default.default.gray("Platform Name:")} ${workflow.name}`);
|
|
2560
|
+
console.log(` ${chalk4__default.default.gray("Mode:")} ${workflow.mode || "workflow"}`);
|
|
2561
|
+
if (workflow.description) {
|
|
2562
|
+
console.log(` ${chalk4__default.default.gray("Description:")} ${workflow.description}`);
|
|
2563
|
+
}
|
|
2564
|
+
}
|
|
2565
|
+
}
|
|
2566
|
+
});
|
|
2567
|
+
} catch (error) {
|
|
2568
|
+
exitWithCommandError4(spinner, "Failed to fetch workflows", error);
|
|
2569
|
+
}
|
|
2570
|
+
}
|
|
2571
|
+
async function getWorkflow(client, options) {
|
|
2572
|
+
const spinner = createSpinner(`Fetching workflow: ${options.id}...`, options.format);
|
|
2573
|
+
try {
|
|
2574
|
+
const workflowService = createWorkflowService(client);
|
|
2575
|
+
const result = await workflowService.get(options.id);
|
|
2576
|
+
if (result.error) {
|
|
2577
|
+
spinner.fail("Failed to fetch workflow");
|
|
2578
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2579
|
+
process.exit(1);
|
|
2580
|
+
}
|
|
2581
|
+
const workflow = result.data;
|
|
2582
|
+
const inputVariables = workflow?.input_variables || [];
|
|
2583
|
+
spinner.succeed("Workflow loaded");
|
|
2584
|
+
renderOutput(workflow, {
|
|
2585
|
+
format: options.format,
|
|
2586
|
+
tableRows: workflow ? [
|
|
2587
|
+
{
|
|
2588
|
+
appId: workflow.app_id,
|
|
2589
|
+
workflowId: workflow.workflow_id,
|
|
2590
|
+
runnableName: workflow.name,
|
|
2591
|
+
version: workflow.version || null,
|
|
2592
|
+
inputVariables: inputVariables.map((item) => item.variable).join(", ")
|
|
2593
|
+
}
|
|
2594
|
+
] : [],
|
|
2595
|
+
csvRows: workflow ? [
|
|
2596
|
+
{
|
|
2597
|
+
appId: workflow.app_id,
|
|
2598
|
+
workflowId: workflow.workflow_id,
|
|
2599
|
+
runnableName: workflow.name,
|
|
2600
|
+
version: workflow.version || null,
|
|
2601
|
+
inputVariables: inputVariables.map((item) => item.variable).join(", ")
|
|
2602
|
+
}
|
|
2603
|
+
] : [],
|
|
2604
|
+
ndjsonItems: workflow ? [workflow] : [],
|
|
2605
|
+
pretty: () => {
|
|
2606
|
+
if (!workflow) {
|
|
2607
|
+
console.log(chalk4__default.default.gray("No workflow found."));
|
|
2608
|
+
return;
|
|
2609
|
+
}
|
|
2610
|
+
console.log(chalk4__default.default.blue(`
|
|
2611
|
+
Workflow: ${workflow.name}
|
|
2612
|
+
`));
|
|
2613
|
+
console.log(`${chalk4__default.default.gray("App ID:")} ${workflow.app_id}`);
|
|
2614
|
+
console.log(`${chalk4__default.default.gray("Workflow ID:")} ${workflow.workflow_id}`);
|
|
2615
|
+
if (workflow.version) {
|
|
2616
|
+
console.log(`${chalk4__default.default.gray("Version:")} ${workflow.version}`);
|
|
2617
|
+
}
|
|
2618
|
+
console.log(`
|
|
2619
|
+
${chalk4__default.default.gray("Input Variables:")}`);
|
|
2620
|
+
if (inputVariables.length === 0) {
|
|
2621
|
+
console.log(chalk4__default.default.gray(" none"));
|
|
2622
|
+
} else {
|
|
2623
|
+
for (const variable of inputVariables) {
|
|
2624
|
+
const label = variable.label ? ` ${chalk4__default.default.gray(`(${variable.label})`)}` : "";
|
|
2625
|
+
const type = variable.type ? ` ${chalk4__default.default.gray(`[${variable.type}]`)}` : "";
|
|
2626
|
+
const required = variable.required ? chalk4__default.default.yellow(" required") : chalk4__default.default.gray(" optional");
|
|
2627
|
+
console.log(` - ${chalk4__default.default.bold(variable.variable)}${label}${type}${required}`);
|
|
2628
|
+
}
|
|
2629
|
+
}
|
|
2630
|
+
console.log(`
|
|
2631
|
+
${chalk4__default.default.gray("Run With:")} amaster workflow run ${workflow.name} --app <app-code> --input '{...}'`);
|
|
2632
|
+
}
|
|
2633
|
+
});
|
|
2634
|
+
} catch (error) {
|
|
2635
|
+
exitWithCommandError4(spinner, "Failed to fetch workflow", error);
|
|
2636
|
+
}
|
|
2637
|
+
}
|
|
2638
|
+
function exitWithCommandError5(spinner, failureMessage, error) {
|
|
2215
2639
|
spinner.fail(failureMessage);
|
|
2216
2640
|
const details = error instanceof Error ? error.message : String(error);
|
|
2217
2641
|
if (details) {
|
|
2218
|
-
console.error(
|
|
2642
|
+
console.error(chalk4__default.default.red(details));
|
|
2219
2643
|
}
|
|
2220
2644
|
process.exit(1);
|
|
2221
2645
|
}
|
|
@@ -2254,20 +2678,20 @@ async function uploadFile(client, options) {
|
|
|
2254
2678
|
const result = await s3Client.upload(file);
|
|
2255
2679
|
if (result.error) {
|
|
2256
2680
|
spinner.fail("Upload failed");
|
|
2257
|
-
console.error(
|
|
2681
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2258
2682
|
process.exit(1);
|
|
2259
2683
|
}
|
|
2260
2684
|
spinner.succeed("Upload complete");
|
|
2261
2685
|
renderOutput(result.data, {
|
|
2262
2686
|
format: options.format,
|
|
2263
2687
|
pretty: () => {
|
|
2264
|
-
console.log(
|
|
2265
|
-
console.log(` ${
|
|
2266
|
-
console.log(` ${
|
|
2688
|
+
console.log(chalk4__default.default.green("\nFile uploaded:"));
|
|
2689
|
+
console.log(` ${chalk4__default.default.bold("Key:")} ${result.data?.key}`);
|
|
2690
|
+
console.log(` ${chalk4__default.default.bold("URL:")} ${result.data?.url || "N/A"}`);
|
|
2267
2691
|
}
|
|
2268
2692
|
});
|
|
2269
2693
|
} catch (error) {
|
|
2270
|
-
|
|
2694
|
+
exitWithCommandError5(spinner, "Upload failed", error);
|
|
2271
2695
|
}
|
|
2272
2696
|
}
|
|
2273
2697
|
async function downloadFile(client, options) {
|
|
@@ -2277,12 +2701,12 @@ async function downloadFile(client, options) {
|
|
|
2277
2701
|
const result = await s3Client.download(options.key);
|
|
2278
2702
|
if (result.error) {
|
|
2279
2703
|
spinner.fail("Download failed");
|
|
2280
|
-
console.error(
|
|
2704
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2281
2705
|
process.exit(1);
|
|
2282
2706
|
}
|
|
2283
2707
|
if (!result.data) {
|
|
2284
2708
|
spinner.fail("Download failed");
|
|
2285
|
-
console.error(
|
|
2709
|
+
console.error(chalk4__default.default.red("Empty file response."));
|
|
2286
2710
|
process.exit(1);
|
|
2287
2711
|
}
|
|
2288
2712
|
const outputPath = path.resolve(options.output);
|
|
@@ -2298,13 +2722,13 @@ async function downloadFile(client, options) {
|
|
|
2298
2722
|
{
|
|
2299
2723
|
format: options.format,
|
|
2300
2724
|
pretty: () => {
|
|
2301
|
-
console.log(
|
|
2725
|
+
console.log(chalk4__default.default.green(`
|
|
2302
2726
|
File saved to: ${outputPath}`));
|
|
2303
2727
|
}
|
|
2304
2728
|
}
|
|
2305
2729
|
);
|
|
2306
2730
|
} catch (error) {
|
|
2307
|
-
|
|
2731
|
+
exitWithCommandError5(spinner, "Download failed", error);
|
|
2308
2732
|
}
|
|
2309
2733
|
}
|
|
2310
2734
|
async function getFileMetadata(client, options) {
|
|
@@ -2314,21 +2738,21 @@ async function getFileMetadata(client, options) {
|
|
|
2314
2738
|
const result = await s3Client.getMetadata(options.key);
|
|
2315
2739
|
if (result.error) {
|
|
2316
2740
|
spinner.fail("Failed to fetch metadata");
|
|
2317
|
-
console.error(
|
|
2741
|
+
console.error(chalk4__default.default.red(result.error.message));
|
|
2318
2742
|
process.exit(1);
|
|
2319
2743
|
}
|
|
2320
2744
|
spinner.succeed("Metadata retrieved");
|
|
2321
2745
|
renderOutput(result.data, {
|
|
2322
2746
|
format: options.format,
|
|
2323
2747
|
pretty: () => {
|
|
2324
|
-
console.log(
|
|
2748
|
+
console.log(chalk4__default.default.blue(`
|
|
2325
2749
|
\u{1F4C4} Metadata for ${options.key}
|
|
2326
2750
|
`));
|
|
2327
2751
|
console.log(JSON.stringify(result.data, null, 2));
|
|
2328
2752
|
}
|
|
2329
2753
|
});
|
|
2330
2754
|
} catch (error) {
|
|
2331
|
-
|
|
2755
|
+
exitWithCommandError5(spinner, "Failed to fetch metadata", error);
|
|
2332
2756
|
}
|
|
2333
2757
|
}
|
|
2334
2758
|
|
|
@@ -2369,8 +2793,8 @@ async function initOpenClaw(options) {
|
|
|
2369
2793
|
const existingConfig = getAppConfig(options.appCode);
|
|
2370
2794
|
if (existingConfig && !options.force) {
|
|
2371
2795
|
spinner.fail(`App already exists: ${options.appCode}`);
|
|
2372
|
-
console.log(
|
|
2373
|
-
console.log(
|
|
2796
|
+
console.log(chalk4__default.default.yellow(`Use --force to reinitialize`));
|
|
2797
|
+
console.log(chalk4__default.default.gray(`Current URL: ${existingConfig.baseURL}`));
|
|
2374
2798
|
process.exit(1);
|
|
2375
2799
|
}
|
|
2376
2800
|
addApp(options.appCode, {
|
|
@@ -2381,8 +2805,8 @@ async function initOpenClaw(options) {
|
|
|
2381
2805
|
if (!openClawDetected) {
|
|
2382
2806
|
spinner.succeed(`App initialized: ${options.appCode}`);
|
|
2383
2807
|
if (pretty) {
|
|
2384
|
-
console.log(
|
|
2385
|
-
console.log(
|
|
2808
|
+
console.log(chalk4__default.default.yellow("\n\u26A0\uFE0F OpenClaw not detected, skipping skill download"));
|
|
2809
|
+
console.log(chalk4__default.default.gray(" Install OpenClaw: npm install -g openclaw"));
|
|
2386
2810
|
} else {
|
|
2387
2811
|
renderOutput(
|
|
2388
2812
|
{
|
|
@@ -2400,9 +2824,9 @@ async function initOpenClaw(options) {
|
|
|
2400
2824
|
}
|
|
2401
2825
|
spinner.succeed(`App initialized: ${options.appCode}`);
|
|
2402
2826
|
if (pretty) {
|
|
2403
|
-
console.log(
|
|
2404
|
-
console.log(` App Code: ${
|
|
2405
|
-
console.log(` Base URL: ${
|
|
2827
|
+
console.log(chalk4__default.default.blue("\n\u{1F4CB} Configuration:\n"));
|
|
2828
|
+
console.log(` App Code: ${chalk4__default.default.green(options.appCode)}`);
|
|
2829
|
+
console.log(` Base URL: ${chalk4__default.default.gray(options.baseURL)}`);
|
|
2406
2830
|
console.log();
|
|
2407
2831
|
}
|
|
2408
2832
|
spinner.start("Downloading skills...");
|
|
@@ -2474,16 +2898,16 @@ async function initOpenClaw(options) {
|
|
|
2474
2898
|
};
|
|
2475
2899
|
if (pretty) {
|
|
2476
2900
|
console.log();
|
|
2477
|
-
console.log(
|
|
2901
|
+
console.log(chalk4__default.default.green("\u2705 Initialization complete!"));
|
|
2478
2902
|
console.log();
|
|
2479
2903
|
console.log(`Next step: Login to your app`);
|
|
2480
|
-
console.log(
|
|
2904
|
+
console.log(chalk4__default.default.gray(` amaster login --app ${options.appCode}`));
|
|
2481
2905
|
console.log();
|
|
2482
2906
|
if (apps.length > 1) {
|
|
2483
|
-
console.log(
|
|
2907
|
+
console.log(chalk4__default.default.blue("Configured apps:"));
|
|
2484
2908
|
for (const app of apps) {
|
|
2485
2909
|
const config = getAppConfig(app);
|
|
2486
|
-
console.log(` ${
|
|
2910
|
+
console.log(` ${chalk4__default.default.gray("\u2022")} ${app} - ${config?.baseURL}`);
|
|
2487
2911
|
}
|
|
2488
2912
|
console.log();
|
|
2489
2913
|
}
|
|
@@ -2584,6 +3008,14 @@ async function downloadMcpConfig(ossEndpoint, appCode) {
|
|
|
2584
3008
|
}
|
|
2585
3009
|
|
|
2586
3010
|
// src/cli.ts
|
|
3011
|
+
function resolveCliVersion() {
|
|
3012
|
+
try {
|
|
3013
|
+
const packageJsonUrl = new URL("../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
|
|
3014
|
+
return JSON.parse(fs.readFileSync(packageJsonUrl, "utf-8")).version || "0.0.0";
|
|
3015
|
+
} catch {
|
|
3016
|
+
return "0.0.0";
|
|
3017
|
+
}
|
|
3018
|
+
}
|
|
2587
3019
|
function resolveAppCode(optionsApp) {
|
|
2588
3020
|
if (optionsApp) {
|
|
2589
3021
|
return optionsApp;
|
|
@@ -2592,38 +3024,39 @@ function resolveAppCode(optionsApp) {
|
|
|
2592
3024
|
if (defaultApp) {
|
|
2593
3025
|
return defaultApp;
|
|
2594
3026
|
}
|
|
2595
|
-
console.error(
|
|
2596
|
-
console.log(
|
|
2597
|
-
console.log(
|
|
2598
|
-
console.log(
|
|
3027
|
+
console.error(chalk4__default.default.red("\u274C No app specified."));
|
|
3028
|
+
console.log(chalk4__default.default.yellow("Use one of:"));
|
|
3029
|
+
console.log(chalk4__default.default.gray(" 1. Add --app <app-code> to the command"));
|
|
3030
|
+
console.log(chalk4__default.default.gray(" 2. Set a default app: amaster use <app-code>"));
|
|
2599
3031
|
process.exit(1);
|
|
2600
3032
|
}
|
|
2601
3033
|
function createAmasterClient(appCode) {
|
|
2602
3034
|
const appConfig = getAppConfig(appCode);
|
|
2603
3035
|
if (!appConfig) {
|
|
2604
|
-
console.error(
|
|
2605
|
-
console.log(
|
|
3036
|
+
console.error(chalk4__default.default.red(`\u274C App not configured: ${appCode}`));
|
|
3037
|
+
console.log(chalk4__default.default.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
|
|
2606
3038
|
process.exit(1);
|
|
2607
3039
|
}
|
|
2608
3040
|
const token = getAccessToken(appCode);
|
|
2609
3041
|
if (token && shouldRefreshToken(appCode)) {
|
|
2610
|
-
console.error(
|
|
3042
|
+
console.error(chalk4__default.default.yellow("\u26A0\uFE0F Session expiring soon. Please login again."));
|
|
2611
3043
|
}
|
|
2612
3044
|
const client$1 = client.createClient({
|
|
2613
3045
|
baseURL: appConfig.baseURL,
|
|
2614
|
-
|
|
2615
|
-
|
|
3046
|
+
headers: {
|
|
3047
|
+
"x-app-code": appCode,
|
|
3048
|
+
...token ? {
|
|
2616
3049
|
Authorization: `Bearer ${token}`
|
|
2617
|
-
}
|
|
2618
|
-
}
|
|
3050
|
+
} : {}
|
|
3051
|
+
},
|
|
2619
3052
|
onUnauthorized: () => {
|
|
2620
3053
|
if (token) {
|
|
2621
|
-
console.error(
|
|
2622
|
-
console.error(
|
|
3054
|
+
console.error(chalk4__default.default.red("\n\u274C Session expired. Please login again."));
|
|
3055
|
+
console.error(chalk4__default.default.yellow(`Run: amaster login --app ${appCode}`));
|
|
2623
3056
|
} else {
|
|
2624
|
-
console.error(
|
|
3057
|
+
console.error(chalk4__default.default.red(`
|
|
2625
3058
|
\u274C Authentication required for app: ${appCode}`));
|
|
2626
|
-
console.error(
|
|
3059
|
+
console.error(chalk4__default.default.yellow(`Run: amaster login --app ${appCode}`));
|
|
2627
3060
|
}
|
|
2628
3061
|
process.exit(1);
|
|
2629
3062
|
}
|
|
@@ -2634,7 +3067,7 @@ function createAmasterClient(appCode) {
|
|
|
2634
3067
|
return client$1;
|
|
2635
3068
|
}
|
|
2636
3069
|
var program = new commander.Command();
|
|
2637
|
-
program.name("amaster").description("CLI for Amaster SDK - Multi-app support for OpenClaw").version(
|
|
3070
|
+
program.name("amaster").description("CLI for Amaster SDK - Multi-app support for OpenClaw").version(resolveCliVersion());
|
|
2638
3071
|
program.command("apps").description("List all configured apps").addOption(createFormatOption()).action((options) => {
|
|
2639
3072
|
const apps = listApps();
|
|
2640
3073
|
const current = getCurrentApp();
|
|
@@ -2650,17 +3083,17 @@ program.command("apps").description("List all configured apps").addOption(create
|
|
|
2650
3083
|
renderOutput(appSummaries, {
|
|
2651
3084
|
format: options.format,
|
|
2652
3085
|
pretty: () => {
|
|
2653
|
-
console.log(
|
|
3086
|
+
console.log(chalk4__default.default.blue("\n\u{1F4F1} Configured Apps\n"));
|
|
2654
3087
|
if (appSummaries.length === 0) {
|
|
2655
|
-
console.log(
|
|
2656
|
-
console.log(
|
|
3088
|
+
console.log(chalk4__default.default.gray(" No apps configured"));
|
|
3089
|
+
console.log(chalk4__default.default.gray(" Run: amaster init --app-code <code> --url <url>"));
|
|
2657
3090
|
} else {
|
|
2658
3091
|
for (const app of appSummaries) {
|
|
2659
|
-
const prefix = app.current ?
|
|
2660
|
-
console.log(`${prefix}${
|
|
2661
|
-
console.log(` ${
|
|
3092
|
+
const prefix = app.current ? chalk4__default.default.green("\u2192 ") : " ";
|
|
3093
|
+
console.log(`${prefix}${chalk4__default.default.bold(app.appCode)}${app.current ? chalk4__default.default.green(" (current)") : ""}`);
|
|
3094
|
+
console.log(` ${chalk4__default.default.gray(app.baseURL || "No URL")}`);
|
|
2662
3095
|
console.log(
|
|
2663
|
-
` ${app.authenticated ?
|
|
3096
|
+
` ${app.authenticated ? chalk4__default.default.green("\u25CF Authenticated") : chalk4__default.default.yellow("\u25CB Not authenticated")}`
|
|
2664
3097
|
);
|
|
2665
3098
|
console.log();
|
|
2666
3099
|
}
|
|
@@ -2679,12 +3112,12 @@ program.command("use <app-code>").description("Set the default app for subsequen
|
|
|
2679
3112
|
{
|
|
2680
3113
|
format: options.format,
|
|
2681
3114
|
pretty: () => {
|
|
2682
|
-
console.log(
|
|
3115
|
+
console.log(chalk4__default.default.green(`\u2705 Now using app: ${appCode}`));
|
|
2683
3116
|
}
|
|
2684
3117
|
}
|
|
2685
3118
|
);
|
|
2686
3119
|
} else {
|
|
2687
|
-
console.error(
|
|
3120
|
+
console.error(chalk4__default.default.red(`\u274C App not found: ${appCode}`));
|
|
2688
3121
|
process.exit(1);
|
|
2689
3122
|
}
|
|
2690
3123
|
});
|
|
@@ -2801,6 +3234,21 @@ entityCmd.command("bulk-delete <namespace> <entity>").description("Bulk delete e
|
|
|
2801
3234
|
format: options.format
|
|
2802
3235
|
});
|
|
2803
3236
|
});
|
|
3237
|
+
var modelCmd = program.command("model").description("Discover runtime datasources and table schemas");
|
|
3238
|
+
modelCmd.command("datasources").description("List runtime datasources with their models").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (options) => {
|
|
3239
|
+
const appCode = resolveAppCode(options.app);
|
|
3240
|
+
await listDatasources(createAmasterClient(appCode), {
|
|
3241
|
+
format: options.format
|
|
3242
|
+
});
|
|
3243
|
+
});
|
|
3244
|
+
modelCmd.command("table-schema <source-id>").description("Get CREATE TABLE statements for one datasource").option("--app <app-code>", "App code (uses default if not specified)").option("--tables <tables>", "Comma-separated table names, JSON array, or @file").addOption(createFormatOption()).action(async (sourceId, options) => {
|
|
3245
|
+
const appCode = resolveAppCode(options.app);
|
|
3246
|
+
await getTableSchema(createAmasterClient(appCode), {
|
|
3247
|
+
sourceId,
|
|
3248
|
+
tables: options.tables,
|
|
3249
|
+
format: options.format
|
|
3250
|
+
});
|
|
3251
|
+
});
|
|
2804
3252
|
var bpmCmd = program.command("bpm").description("Manage BPM processes and tasks");
|
|
2805
3253
|
bpmCmd.command("processes").description("List process definitions").option("--app <app-code>", "App code (uses default if not specified)").option("--key <key>", "Filter by process definition key").option("--name <name>", "Filter by process definition name").option("--latest-version", "Only return latest version").option("--active", "Only return active process definitions").option("--suspended", "Only return suspended process definitions").option("--sort-by <field>", "Sort field").addOption(new commander.Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional ProcessDefinitionQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
|
|
2806
3254
|
const appCode = resolveAppCode(options.app);
|
|
@@ -3153,7 +3601,25 @@ bpmCmd.command("start-form-deployed <key>").description("Get deployed start form
|
|
|
3153
3601
|
format: options.format
|
|
3154
3602
|
});
|
|
3155
3603
|
});
|
|
3156
|
-
var workflowCmd = program.command("workflow").description("
|
|
3604
|
+
var workflowCmd = program.command("workflow").description("Inspect and run workflows");
|
|
3605
|
+
workflowCmd.command("list").description("List runnable workflows").option("--app <app-code>", "App code (uses default if not specified)").option("--page <n>", "Page number").option("--limit <n>", "Page size").addOption(
|
|
3606
|
+
new commander.Option("--mode <mode>", "Workflow app mode").choices(["workflow", "chat", "completion", "agent-chat"])
|
|
3607
|
+
).addOption(createFormatOption()).action(async (options) => {
|
|
3608
|
+
const appCode = resolveAppCode(options.app);
|
|
3609
|
+
await listWorkflows(createAmasterClient(appCode), {
|
|
3610
|
+
page: options.page ? parseInt(options.page, 10) : void 0,
|
|
3611
|
+
limit: options.limit ? parseInt(options.limit, 10) : void 0,
|
|
3612
|
+
mode: options.mode,
|
|
3613
|
+
format: options.format
|
|
3614
|
+
});
|
|
3615
|
+
});
|
|
3616
|
+
workflowCmd.command("get <id>").alias("inspect").description("Get workflow details and input variables by workflow app ID").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
|
|
3617
|
+
const appCode = resolveAppCode(options.app);
|
|
3618
|
+
await getWorkflow(createAmasterClient(appCode), {
|
|
3619
|
+
id,
|
|
3620
|
+
format: options.format
|
|
3621
|
+
});
|
|
3622
|
+
});
|
|
3157
3623
|
workflowCmd.command("run <name>").alias("execute").description("Run a workflow").option("--app <app-code>", "App code (uses default if not specified)").option("-i, --input <json>", "Workflow inputs object as JSON or @file").option("-r, --request <json>", "Full WorkflowRunRequest as JSON or @file").addOption(
|
|
3158
3624
|
new commander.Option("--response-mode <mode>", "Workflow response mode").choices(["blocking", "streaming"])
|
|
3159
3625
|
).option("--user <user>", "Workflow user identifier").option("--files <json>", "Workflow files array as JSON or @file").option("--trace-id <traceId>", "Workflow trace ID").addOption(createFormatOption()).action(async (name, options) => {
|