diff --git a/ivaldi.json b/ivaldi.json index 9d692cf..87e1136 100644 --- a/ivaldi.json +++ b/ivaldi.json @@ -10,6 +10,7 @@ "ical", "telegram", "conf", + "log", "args" ] } @@ -19,6 +20,8 @@ "types.ts", "sources/kalender_digital.ts", "sources/_functions.ts", + "targets/telegram_bot.ts", + "targets/_functions.ts", "conf.ts", "main.ts" ] diff --git a/libs/plankton/plankton.d.ts b/libs/plankton/plankton.d.ts index f98653b..7c85a19 100644 --- a/libs/plankton/plankton.d.ts +++ b/libs/plankton/plankton.d.ts @@ -2258,7 +2258,9 @@ declare namespace lib_plankton.telegram { /** * @see https://core.telegram.org/bots/api#sendmessage */ - function bot_call_send_message(token: string, chat_id: (int | string), text: string): Promise; + function bot_call_send_message(token: string, chat_id: (int | string), text: string, { "parse_mode": parse_mode, }?: { + parse_mode?: (null | string); + }): Promise; } declare namespace lib_plankton.file { /** diff --git a/libs/plankton/plankton.js b/libs/plankton/plankton.js index 4bab22f..2431de4 100644 --- a/libs/plankton/plankton.js +++ b/libs/plankton/plankton.js @@ -6243,10 +6243,11 @@ var lib_plankton; /** * @see https://core.telegram.org/bots/api#sendmessage */ - async function bot_call_send_message(token, chat_id, text) { + async function bot_call_send_message(token, chat_id, text, { "parse_mode": parse_mode = null, } = {}) { const output = await bot_call_generic(token, "sendMessage", { "chat_id": chat_id, "text": text, + "parse_mode": (parse_mode ?? undefined), }); } telegram.bot_call_send_message = bot_call_send_message; diff --git a/readme.md b/readme.md index 2b0e99e..f1b8470 100644 --- a/readme.md +++ b/readme.md @@ -2,3 +2,29 @@ Sendet Erinnerungen an Termine + +## Erstellung + +### Erfordernisse + +- GNU Make +- Typescript Compiler + + +### Anweisungen + +- `tools/build` + + +## Verwendung + +### Erfordernisse + +- NodeJS + + +### Anweisungen + +siehe `munin -h` + + diff --git a/source/conf.ts b/source/conf.ts index a62ef83..cded882 100644 --- a/source/conf.ts +++ b/source/conf.ts @@ -1,16 +1,38 @@ -namespace _lixer_event_reminder.conf +/* +This file is part of »munin«. + +Copyright 2025 'Fenris Wolf' + +»munin« is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +»munin« is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with »munin«. If not, see . + */ + + +/** + * @todo versioning + */ +namespace _munin.conf { /** */ export type type_conf = { - bot_token : string; sources : Array< ( { kind : "kalender_digital", data : { - id : string; + path : string; filtration : { category_blacklist : Array; title_blacklist : Array; @@ -20,11 +42,30 @@ namespace _lixer_event_reminder.conf ) >; targets : Array< - { - chat_id : int; - interval : Array; - } + ( + { + kind : "telegram_bot", + data : { + bot_token : string; + chat_id : int; + /** + * in hours + */ + interval : Array; + } + } + ) >; + /** + * in hours + */ + frequency : float; + labels : { + head : string; + title : string; + time : string; + location : string; + }; }; @@ -38,10 +79,6 @@ namespace _lixer_event_reminder.conf "nullable": false, "type": "string", }, - "bot_token": { - "nullable": false, - "type": "string", - }, "sources": { "nullable": false, "type": "array", @@ -60,7 +97,7 @@ namespace _lixer_event_reminder.conf "nullable": false, "type": "object", "properties": { - "id": { + "path": { "nullable": false, "type": "string" }, @@ -74,7 +111,8 @@ namespace _lixer_event_reminder.conf "items": { "nullable": false, "type": "string", - } + }, + "default": [], }, "title_blacklist": { "nullable": false, @@ -82,20 +120,19 @@ namespace _lixer_event_reminder.conf "items": { "nullable": false, "type": "string", - } + }, + "default": [], }, }, "additionalProperties": false, "required": [ - "category_blacklist", - "title_blacklist", - ] + ], + "default": {} }, }, "additionalProperties": false, "required": [ "id", - "filtration", ] } }, @@ -113,35 +150,95 @@ namespace _lixer_event_reminder.conf "type": "array", "items": { "nullable": false, - "type": "object", - "properties": { - "chat_id": { + "anyOf": [ + { "nullable": false, - "type": "integer", - }, - "interval": { - "nullable": false, - "type": "array", - "items": { - "nullable": false, - "type": "integer" - } - }, - }, - "additionalProperties": false, - "required": [ - "chat_id", - "interval", - ] + "type": "object", + "properties": { + "kind": { + "nullable": false, + "type": "string", + "enum": ["telegram_bot"] + }, + "data": { + "nullable": false, + "type": "object", + "properties": { + "bot_token": { + "nullable": false, + "type": "string", + }, + "chat_id": { + "nullable": false, + "type": "integer", + }, + "interval": { + "nullable": false, + "type": "array", + "items": { + "nullable": false, + "type": "integer" + }, + "default": [24.0], + }, + }, + "additionalProperties": false, + "required": [ + "bot_token", + "chat_id", + ] + } + }, + "additionalProperties": false, + "required": [ + "kind", + "data", + ] + } + ], } }, + "frequency": { + "nullable": false, + "type": "number", + "default": 1.0, + }, + "labels": { + "nullable": false, + "type": "object", + "properties": { + "head": { + "nullable": false, + "type": "string", + "default": "Termin-Erinnerung" + }, + "title": { + "nullable": false, + "type": "string", + "default": "was" + }, + "time": { + "nullable": false, + "type": "string", + "default": "wann" + }, + "location": { + "nullable": false, + "type": "string", + "default": "wo" + }, + }, + "additionalProperties": false, + "required": [ + ], + "default": {} + }, }, "additionalProperties": false, "required": [ "version", - "bot_token", - "chat_id", - "intval", + "sources", + "targets", ], }; diff --git a/source/main.ts b/source/main.ts index 1d7fe53..e347e40 100644 --- a/source/main.ts +++ b/source/main.ts @@ -1,6 +1,143 @@ -namespace _lixer_event_reminder +/* +This file is part of »munin«. + +Copyright 2025 'Fenris Wolf' + +»munin« is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +»munin« is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with »munin«. If not, see . + */ + + +namespace _munin { + /** + */ + async function run_iteration( + conf : _munin.conf.type_conf, + sources : Array<_munin.type_source>, + targets : Array<_munin.type_target>, + { + "dry_run": dry_run = false, + } : { + dry_run ?: boolean; + } = { + } + ) : Promise + { + const now : lib_plankton.pit.type_pit = lib_plankton.pit.now(); + const events : Array<_munin.type_event> = ( + (await Promise.all(sources.map(source => source.fetch()))) + .reduce((x, y) => x.concat(y), []) + ); + for (const target of targets) { + lib_plankton.log._info( + "munin.run.iteration", + { + "details": { + "target": target, + } + } + ); + for (const hours of target.interval) { + const window_from : lib_plankton.pit.type_pit = lib_plankton.pit.shift_hour( + now, + hours + 0 + ); + const window_to : lib_plankton.pit.type_pit = lib_plankton.pit.shift_hour( + now, + hours + (conf.frequency / 2) + ); + for (const event of events) { + const event_begin : lib_plankton.pit.type_pit = lib_plankton.pit.from_datetime(event.begin); + lib_plankton.log._debug( + "munin.run.check_dueness", + { + "details": { + "event_begin": lib_plankton.pit.datetime_format(lib_plankton.pit.to_datetime(event_begin)), + "window_from": lib_plankton.pit.datetime_format(lib_plankton.pit.to_datetime(window_from)), + "window_to": lib_plankton.pit.datetime_format(lib_plankton.pit.to_datetime(window_to)), + } + } + ); + const remind : boolean = lib_plankton.pit.is_between( + event_begin, + window_from, + window_to + ); + if (! remind) { + // do nothing + } + else { + lib_plankton.log._info( + "munin.remind", + { + "details": { + "event": event, + "target": target, + } + } + ); + if (dry_run) { + // do nothing + } + else { + await target.send(conf.labels, event); + } + } + } + } + } + } + + + /** + */ + function run( + conf : _munin.conf.type_conf, + { + "dry_run": dry_run = false, + } : { + dry_run ?: boolean; + } = { + } + ) : void + { + const sources : Array<_munin.type_source> = conf.sources.map( + source_raw => _munin.sources.factory(source_raw) + ); + const targets : Array<_munin.type_target> = conf.targets.map( + target_raw => _munin.targets.factory(target_raw) + ); + lib_plankton.log._info( + "munin.run.start", + { + "details": { + } + } + ); + run_iteration(conf, sources, targets, {"dry_run": dry_run}); + /** + * outsource setInterval logic + */ + setInterval( + () => {run_iteration(conf, sources, targets, {"dry_run": dry_run});}, + (conf.frequency * 60 * 60 * 1000) + ); + + } + + /** */ export async function main( @@ -27,14 +164,32 @@ namespace _lixer_event_reminder "info": "path to configuration file", "name": "conf-path", }), - "message": lib_plankton.args.class_argument.volatile({ - "indicators_long": ["message"], - "indicators_short": ["m"], + "conf_expose": lib_plankton.args.class_argument.volatile({ + "indicators_long": ["conf-expose"], + "indicators_short": ["e"], + "type": lib_plankton.args.enum_type.boolean, + "mode": lib_plankton.args.enum_mode.replace, + "default": false, + "info": "whether to expose the full configuration", + "name": "conf-expose", + }), + "verbosity": lib_plankton.args.class_argument.volatile({ + "indicators_long": ["verbosity"], + "indicators_short": ["v"], "type": lib_plankton.args.enum_type.string, "mode": lib_plankton.args.enum_mode.replace, - "default": "test", - "info": "message to send", - "name": "message", + "default": "notice", + "info": "error | warning | notice | info | debug", + "name": "verbosity", + }), + "dry_run": lib_plankton.args.class_argument.volatile({ + "indicators_long": ["dry-run"], + "indicators_short": ["q"], + "type": lib_plankton.args.enum_type.boolean, + "mode": lib_plankton.args.enum_mode.replace, + "default": false, + "info": "whether to not skip the sending of reminders (logs will be written)", + "name": "dry-run", }), "help": lib_plankton.args.class_argument.volatile({ "indicators_long": ["help"], @@ -52,13 +207,6 @@ namespace _lixer_event_reminder args_raw.join(" ") ); - // init - const conf : _lixer_event_reminder.conf.type_conf = await lib_plankton.conf.load<_lixer_event_reminder.conf.type_conf>( - _lixer_event_reminder.conf.schema, - args.conf_path - ); - - // exec if (args.help || (args.action === "help")) { process.stdout.write( arg_handler.generate_help( @@ -71,83 +219,69 @@ namespace _lixer_event_reminder ); } else { + // init + const conf : _munin.conf.type_conf = await lib_plankton.conf.load<_munin.conf.type_conf>( + _munin.conf.schema, + args.conf_path + ); + lib_plankton.log.set_main_logger( + [ + { + "kind": "filtered", + "data": { + "core": { + "kind": "std", + "data": { + "target": "stdout", + "format": { + "kind": "human_readable", + "data": { + } + } + } + }, + "predicate": [ + [ + { + "item": { + "kind": "level", + "data": { + "threshold": args.verbosity, + } + }, + } + ] + ], + } + }, + ] + ); + + // exec + if (args.conf_expose) { + process.stdout.write( + lib_plankton.json.encode( + conf, + { + "formatted": true, + } + ) + + + "\n" + ); + } switch (args.action) { default: { throw (new Error("unhandled action: " + args.action)); break; } - case "fetch": { - const updates : Array = await lib_plankton.telegram.bot_call_get_updates( - conf.bot_token - ); - process.stdout.write(JSON.stringify(updates, undefined, "\t") + "\n"); - break; - } - case "send": { - for (const target of conf.targets) { - const message = await lib_plankton.telegram.bot_call_send_message( - conf.bot_token, - target.chat_id, - args.message - ); - } - break; - } case "run": { - const sources : Array<_lixer_event_reminder.type_source> = conf.sources.map( - source_raw => _lixer_event_reminder.sources.factory(source_raw) - ); - const targets : Array<_lixer_event_reminder.type_target> = conf.targets.map( - target_raw => target_raw - ); - const now : lib_plankton.pit.type_pit = lib_plankton.pit.now(); - - const events : Array<_lixer_event_reminder.type_event> = ( - (await Promise.all(sources.map(source => source.fetch()))) - .reduce((x, y) => x.concat(y), []) - ); - for (const event of events) { - const begin : lib_plankton.pit.type_pit = lib_plankton.pit.from_datetime(event.begin); - for (const target of targets) { - for (const hours of target.interval) { - const remind : boolean = lib_plankton.pit.is_between( - lib_plankton.pit.shift_hour(begin, hours), - now, - /** - * @todo parametrize window - */ - lib_plankton.pit.shift_hour(now, +24) - ); - if (remind) { - lib_plankton.log._info( - "remind", - { - "details": { - "event": event, - "target": target, - } - } - ); - /** - * @todo activate - * @todo format better - */ - const message = await lib_plankton.telegram.bot_call_send_message( - conf.bot_token, - target.chat_id, - lib_plankton.string.coin( - "{{title}} | {{begin}}", - { - "title": event.title, - "begin": lib_plankton.pit.datetime_format(event.begin), - } - ) - ); - } - } + run( + conf, + { + "dry_run": args.dry_run, } - } - + ); break; } } @@ -157,7 +291,7 @@ namespace _lixer_event_reminder } } -_lixer_event_reminder.main(process.argv.slice(2)) +_munin.main(process.argv.slice(2)) .then(() => {}) .catch((reason) => {process.stderr.write(String(reason) + "\n");}) ; diff --git a/source/sources/_functions.ts b/source/sources/_functions.ts index 7965815..6f09abd 100644 --- a/source/sources/_functions.ts +++ b/source/sources/_functions.ts @@ -1,4 +1,24 @@ -namespace _lixer_event_reminder.sources +/* +This file is part of »munin«. + +Copyright 2025 'Fenris Wolf' + +»munin« is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +»munin« is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with »munin«. If not, see . + */ + + +namespace _munin.sources { /** @@ -8,7 +28,7 @@ namespace _lixer_event_reminder.sources kind : string, data : any } - ) : type_source + ) : _munin.type_source { switch (description.kind) { default: { @@ -16,8 +36,8 @@ namespace _lixer_event_reminder.sources break; } case "kalender_digital": { - return _lixer_event_reminder.sources.kalender_digital.implementation_source( - description.data as _lixer_event_reminder.sources.kalender_digital.type_parameters + return _munin.sources.kalender_digital.implementation_source( + description.data as _munin.sources.kalender_digital.type_parameters ); return } diff --git a/source/sources/kalender_digital.ts b/source/sources/kalender_digital.ts index 89cd5f8..3af37ba 100644 --- a/source/sources/kalender_digital.ts +++ b/source/sources/kalender_digital.ts @@ -1,10 +1,10 @@ -namespace _lixer_event_reminder.sources.kalender_digital +namespace _munin.sources.kalender_digital { /** */ export type type_parameters = { - id : string; + path : string; filtration : { category_blacklist : Array; title_blacklist : Array; @@ -16,15 +16,15 @@ namespace _lixer_event_reminder.sources.kalender_digital */ async function fetch( parameters : type_parameters - ) : Promise> + ) : Promise> { const http_request : lib_plankton.http.type_request = { "scheme": "https", "host": "export.kalender.digital", "path": lib_plankton.string.coin( - "/ics/0/{{id}}/gesamterkalender.ics", + "/ics/{{path}}.ics", { - "id": parameters.id, + "path": parameters.path, } ), "version": "HTTP/2", @@ -33,7 +33,10 @@ namespace _lixer_event_reminder.sources.kalender_digital "?past_months={{past_months}}&future_months={{future_months}}", { "past_months": (0).toFixed(0), - "future_months": (2).toFixed(0), + /** + * anpassen an frequency? + */ + "future_months": (1).toFixed(0), } ), "headers": {}, @@ -42,13 +45,34 @@ namespace _lixer_event_reminder.sources.kalender_digital const http_response : lib_plankton.http.type_response = await lib_plankton.http.call(http_request); const ics : string = http_response.body.toString(); const vcalendar : lib_plankton.ical.type_vcalendar = lib_plankton.ical.ics_decode(ics); - const events : Array<_lixer_event_reminder.type_event> = ( + const events : Array<_munin.type_event> = ( vcalendar.vevents .filter( vevent => ( - vevent.categories.every(category => ! parameters.filtration.category_blacklist.includes(category)) + // category + ( + vevent.categories.every( + category => ( + ! ( + parameters.filtration.category_blacklist + .map(category_ => category_.toLowerCase()) + .includes(category.toLowerCase()) + ) + ) + ) + ) && - parameters.filtration.title_blacklist.every(title => ! vevent.summary.toLowerCase().includes(title.toLowerCase())) + // title + ( + parameters.filtration.title_blacklist.every( + title => ( + ! ( + vevent.summary.toLowerCase() + .includes(title.toLowerCase()) + ) + ) + ) + ) ) ) .map( @@ -63,11 +87,11 @@ namespace _lixer_event_reminder.sources.kalender_digital "date": vevent.dtend.value.date, "time": vevent.dtend.value.time, }; - const event : _lixer_event_reminder.type_event = { + const event : _munin.type_event = { "title": vevent.summary, "begin": begin, "end": end, - "location": vevent.location, + "location": (vevent.location ?? null), }; return event; } @@ -81,7 +105,7 @@ namespace _lixer_event_reminder.sources.kalender_digital */ export function implementation_source( parameters : type_parameters - ) : _lixer_event_reminder.type_source + ) : _munin.type_source { return { "fetch": () => fetch(parameters), diff --git a/source/targets/_functions.ts b/source/targets/_functions.ts new file mode 100644 index 0000000..b6d0e34 --- /dev/null +++ b/source/targets/_functions.ts @@ -0,0 +1,48 @@ +/* +This file is part of »munin«. + +Copyright 2025 'Fenris Wolf' + +»munin« is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +»munin« is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with »munin«. If not, see . + */ + + +namespace _munin.targets +{ + + /** + */ + export function factory( + description : { + kind : string, + data : any + } + ) : _munin.type_target + { + switch (description.kind) { + default: { + throw (new Error("unhandled target kind: " + description.kind)); + break; + } + case "telegram_bot": { + return _munin.targets.telegram_bot.implementation_target( + description.data as _munin.targets.telegram_bot.type_parameters + ); + return + } + } + } + +} + diff --git a/source/targets/telegram_bot.ts b/source/targets/telegram_bot.ts new file mode 100644 index 0000000..17a194c --- /dev/null +++ b/source/targets/telegram_bot.ts @@ -0,0 +1,87 @@ +/* +This file is part of »munin«. + +Copyright 2025 'Fenris Wolf' + +»munin« is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +»munin« is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with »munin«. If not, see . + */ + + +namespace _munin.targets.telegram_bot +{ + + /** + */ + export type type_parameters = { + bot_token : string; + chat_id : int; + interval : Array; + }; + + + /** + */ + async function send( + parameters : type_parameters, + labels : _munin.type_labels, + event : _munin.type_event + ) : Promise + { + await lib_plankton.telegram.bot_call_send_message( + parameters.bot_token, + parameters.chat_id, + lib_plankton.string.coin( + "*{{head}}*\n\n\{{title_label}} | {{title_value}}\n{{time_label}} | {{time_value}}{{macro_location}}", + { + "head": labels.head, + "title_label": labels.title.toUpperCase(), + "title_value": event.title, + "time_label": labels.time.toUpperCase(), + "time_value": lib_plankton.pit.timespan_format(event.begin, event.end), + "macro_location": ( + (event.location === null) + ? + "" + : + lib_plankton.string.coin( + "\n{{location_label}} | {{location_value}}", + { + "location_label": labels.location.toUpperCase(), + "location_value": event.location, + } + ) + ), + } + ), + { + "parse_mode": "markdown", + } + ); + } + + + /** + */ + export function implementation_target( + parameters : type_parameters + ) : _munin.type_target + { + return { + "interval": parameters.interval, + "send": (labels, event) => send(parameters, labels, event), + }; + } + +} + diff --git a/source/types.ts b/source/types.ts index 12c4848..b698d64 100644 --- a/source/types.ts +++ b/source/types.ts @@ -1,6 +1,16 @@ -namespace _lixer_event_reminder +namespace _munin { + + /** + */ + export type type_labels = { + head : string; + title : string; + time : string; + location : string; + }; + /** */ export type type_event = { @@ -9,20 +19,32 @@ namespace _lixer_event_reminder end : (null | lib_plankton.pit.type_datetime), location : (null | string); }; + - /** */ export type type_source = { - fetch : (() => Promise>); + fetch : ( + ( + ) + => + Promise> + ); }; - + /** */ export type type_target = { - chat_id : int; interval : Array; + send : ( + ( + labels : type_labels, + event : type_event + ) + => + Promise + ); }; } diff --git a/tools/clear b/tools/clear old mode 100644 new mode 100755 diff --git a/tools/ivaldi b/tools/ivaldi index f3195d8..51bca78 100755 --- a/tools/ivaldi +++ b/tools/ivaldi @@ -5076,43 +5076,43 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; /* -This file is part of »munin«. +This file is part of »ivaldi«. Copyright 2025 'Fenris Wolf' -»munin« is free software: you can redistribute it and/or modify +»ivaldi« is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. -»munin« is distributed in the hope that it will be useful, +»ivaldi« is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License -along with »munin«. If not, see . +along with »ivaldi«. If not, see . */ /* -This file is part of »munin«. +This file is part of »ivaldi«. Copyright 2025 'Fenris Wolf' -»munin« is free software: you can redistribute it and/or modify +»ivaldi« is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. -»munin« is distributed in the hope that it will be useful, +»ivaldi« is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License -along with »munin«. If not, see . +along with »ivaldi«. If not, see . */ -var _munin; -(function (_munin) { +var _ivaldi; +(function (_ivaldi) { /** * @todo outsource */ @@ -5252,9 +5252,9 @@ var _munin; "libs": "libs", "temp": "temp", "build": "build", + "makefile": "/tmp", }, "command_tsc": "tsc", - "makefile_path": "/tmp/ivaldi-makefile", }; switch (args.action) { default: { @@ -5432,11 +5432,17 @@ var _munin; "break_dependencies": true, "silent_actions": true, }); - yield lib_plankton.file.write(conf.makefile_path, makefile); - const command = lib_plankton.string.coin("make -f {{path}}", { - "path": conf.makefile_path, + const makefile_path = lib_plankton.string.coin("{{directory}}/ivaldi-makefile-{{name}}", { + "directory": conf.directories.makefile, + "name": data.name, }); - yield execute(command); + yield lib_plankton.file.write(makefile_path, makefile); + const command = lib_plankton.string.coin("make -f {{path}}", { + "path": makefile_path, + }); + const result = yield execute(command); + process.stdout.write(result.stdout + "\n"); + process.stderr.write(result.stderr + "\n"); return Promise.resolve(undefined); break; } @@ -5448,8 +5454,8 @@ var _munin; } }); } - _munin.main = main; -})(_munin || (_munin = {})); -_munin.main(process.argv.slice(2)) + _ivaldi.main = main; +})(_ivaldi || (_ivaldi = {})); +_ivaldi.main(process.argv.slice(2)) .then(() => { }) .catch((reason) => { process.stderr.write(String(reason) + "\n"); });