@mittwald/cli 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/esm/commands/conversation/show.js

@@ -2,7 +2,7 @@ import { BaseCommand } from "../../BaseCommand.js";
 import { Args } from "@oclif/core";
 import { normalizeConversationIdToUuid } from "../../Helpers.js";
 import { assertStatus } from "@mittwald/api-client-commons";
-import { formatDate } from "../../lib/viewhelpers/date.js";
+import { formatRelativeDate } from "../../lib/viewhelpers/date.js";
 import { marked } from "marked";
 import TerminalRenderer from "marked-terminal";
 import chalk from "chalk";
@@ -20,10 +20,10 @@ export default class Show extends BaseCommand {
         const conversationId = await normalizeConversationIdToUuid(this.apiClient, args.id);
         const [conversationResponse, messagesResponse] = await Promise.all([
             this.apiClient.conversation.getConversation({
-                pathParameters: { conversationId },
+                conversationId,
             }),
             this.apiClient.conversation.listMessagesByConversation({
-                pathParameters: { conversationId },
+                conversationId,
             }),
         ]);
         assertStatus(conversationResponse, 200);
@@ -33,25 +33,21 @@ export default class Show extends BaseCommand {
         printKeyValues({
             Title: conv.title,
             ID: conv.shortId,
-            Opened: `${formatDate(conv.createdAt)} by ${conv.createdBy ? conv.createdBy.clearName : "Unknown User"}`,
+            Opened: `${formatRelativeDate(conv.createdAt)} by ${conv.createdBy ? conv.createdBy.clearName : "Unknown User"}`,
             Status: conv.status,
         });
         console.log();
         printHeader("Messages");
         marked.setOptions({
             renderer: new TerminalRenderer(),
-            mangle: false,
-            headerIds: false,
-            headerPrefix: "",
         });
         const metaColor = chalk.gray;
         for (const msg of messagesResponse.data) {
             if (msg.type === "MESSAGE") {
-                console.log(chalk.whiteBright.underline(`${msg.createdBy?.clearName}, ${formatDate(msg.createdAt)}`));
-                const rendered = marked(msg.messageContent ?? "")
+                console.log(chalk.whiteBright.underline(`${msg.createdBy?.clearName}, ${formatRelativeDate(msg.createdAt)}`));
+                const rendered = (await marked(msg.messageContent ?? ""))
                     .trim()
                     .split("\n")
-                    //.map((l) => `| ${l}`)
                     .join("\n");
                 console.log(rendered);
                 console.log();
@@ -59,16 +55,16 @@ export default class Show extends BaseCommand {
             else {
                 switch (msg.messageContent) {
                     case "CONVERSATION_CREATED":
-                        console.log(metaColor(`CREATED, ${formatDate(msg.createdAt)}`));
+                        console.log(metaColor(`CREATED, ${formatRelativeDate(msg.createdAt)}`));
                         break;
                     case "STATUS_OPEN":
-                        console.log(metaColor(`REOPENED, ${formatDate(msg.createdAt)}`));
+                        console.log(metaColor(`REOPENED, ${formatRelativeDate(msg.createdAt)}`));
                         break;
                     case "STATUS_CLOSED":
-                        console.log(metaColor(`CLOSED, ${formatDate(msg.createdAt)}`));
+                        console.log(metaColor(`CLOSED, ${formatRelativeDate(msg.createdAt)}`));
                         break;
                     default:
-                        console.log(metaColor(`${msg.messageContent}, ${formatDate(msg.createdAt)}`));
+                        console.log(metaColor(`${msg.messageContent}, ${formatRelativeDate(msg.createdAt)}`));
                         break;
                 }
                 console.log();

package/dist/esm/commands/conversation/show2.js

@@ -6,13 +6,14 @@ import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
 import { useRenderContext } from "../../rendering/react/context.js";
 import { UsePromiseRenderSetup } from "../../rendering/setup/usePromiseSetup.js";
 import { Box } from "ink";
-import { ConversationMeta } from "../../rendering/react/components/ConversationMeta.js";
+import { ConversationMeta } from "../../rendering/react/components/Conversation/ConversationMeta.js";
 import { Args } from "@oclif/core";
-import { ConversationMessage } from "../../rendering/react/components/ConversationMessage.js";
+import { ConversationMessages } from "../../rendering/react/components/Conversation/ConversationMessages.js";
 const usePromiseSetup = new UsePromiseRenderSetup();
 export default class Show extends RenderBaseCommand {
     static flags = {
         ...usePromiseSetup.flags,
+        ...RenderBaseCommand.buildFlags(),
     };
     static args = {
         conversationId: Args.string({
@@ -22,16 +23,16 @@ export default class Show extends RenderBaseCommand {
     render() {
         const { apiClient } = useRenderContext();
         const { conversationId } = this.args;
+        const usePromiseOptions = usePromiseSetup.getSetup(this.flags);
         const response = usePromise(apiClient.conversation.listMessagesByConversation, [
             {
-                pathParameters: {
-                    conversationId,
-                },
+                conversationId,
             },
         ], {
             loaderId: "listMessagesByConversation",
+            ...usePromiseOptions,
         });
         assertStatus(response, 200);
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Suspense, { fallback: null, children: _jsx(ConversationMeta, { id: conversationId }) }), _jsx(Box, { flexDirection: "column", children: response.data.map((msg, index) => (_jsx(ConversationMessage, { message: msg }, index))) })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Suspense, { fallback: null, children: _jsx(ConversationMeta, { id: conversationId }) }), _jsx(ConversationMessages, { messages: response.data })] }));
     }
 }

package/dist/esm/commands/cronjob/create.d.ts

@@ -0,0 +1,23 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    cronjobId: string;
+};
+export declare class Create extends ExecRenderBaseCommand<typeof Create, Result> {
+    static summary: string;
+    static flags: {
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        interval: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        disable: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        email: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        url: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        interpreter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        command: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ cronjobId }: Result): ReactNode;
+}
+export {};

package/dist/esm/commands/cronjob/create.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { appInstallationFlags } from "../../lib/app/flags.js";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new cron job";
+    static flags = {
+        ...appInstallationFlags,
+        ...processFlags,
+        description: Flags.string({
+            required: true,
+            summary: "Description of the cron job",
+            default: undefined,
+        }),
+        interval: Flags.string({
+            required: true,
+            summary: "Interval of the cron job, in standard UNIX cron syntax",
+            default: undefined,
+        }),
+        disable: Flags.boolean({
+            summary: "Disable the cron job after creation",
+            default: false,
+        }),
+        email: Flags.string({
+            required: false,
+            summary: "Email address to send cron job output to",
+            default: undefined,
+        }),
+        url: Flags.string({
+            required: false,
+            summary: "URL to call for the cron job; either this or `--command` is required.",
+            default: undefined,
+            exclusive: ["command"],
+        }),
+        interpreter: Flags.string({
+            required: false,
+            summary: "Interpreter to use for the cron job",
+            default: "/bin/sh",
+        }),
+        command: Flags.string({
+            required: false,
+            summary: "Command to execute for the cron job; either this or `--url` is required.",
+            default: undefined,
+            exclusive: ["url"],
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating a new cron job");
+        const appInstallationId = await this.withAppInstallationId(Create);
+        const { description, interval, disable, email, url, interpreter, command } = this.flags;
+        if (!url && !command) {
+            throw new Error("either `--url` or `--command` must be specified");
+        }
+        const { projectId } = await p.runStep("fetching project", async () => {
+            const r = await this.apiClient.app.getAppinstallation({
+                appInstallationId,
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        if (!projectId) {
+            throw new Error("no project found for app installation");
+        }
+        const { id: cronjobId } = await p.runStep("creating cron job", async () => {
+            const r = await this.apiClient.cronjob.createCronjob({
+                projectId,
+                data: {
+                    appId: appInstallationId,
+                    active: !disable,
+                    description,
+                    interval,
+                    email,
+                    destination: url ? { url } : { interpreter, path: command },
+                    timeout: 3600,
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        const cronjob = await p.runStep("fetching cron job", async () => {
+            const r = await this.apiClient.cronjob.getCronjob({ cronjobId });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        p.complete(_jsxs(Success, { children: ["The cron job ", _jsx(Value, { children: cronjob.shortId }), " was successfully created."] }));
+        return { cronjobId };
+    }
+    render({ cronjobId }) {
+        if (this.flags.quiet) {
+            return cronjobId;
+        }
+    }
+}

package/dist/esm/commands/cronjob/delete.d.ts

@@ -0,0 +1,13 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+export default class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static flags: {
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/esm/commands/cronjob/delete.js

@@ -0,0 +1,21 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+import { Args } from "@oclif/core";
+import assertSuccess from "../../lib/assert_success.js";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a cron job";
+    static resourceName = "cron job";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cronjob to be deleted.",
+            required: true,
+        }),
+    };
+    async deleteResource() {
+        const { "cronjob-id": cronjobId } = this.args;
+        const response = await this.apiClient.cronjob.deleteCronjob({
+            cronjobId,
+        });
+        assertSuccess(response);
+    }
+}

package/dist/esm/commands/cronjob/execute.d.ts

@@ -0,0 +1,17 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    executionId: string;
+};
+export declare class Execute extends ExecRenderBaseCommand<typeof Execute, Result> {
+    static summary: string;
+    static flags: {
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ executionId }: Result): ReactNode;
+}
+export {};

package/dist/esm/commands/cronjob/execute.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Args } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+export class Execute extends ExecRenderBaseCommand {
+    static summary = "Manually run a cron job";
+    static flags = {
+        ...processFlags,
+    };
+    static args = {
+        "cronjob-id": Args.string({
+            required: true,
+            summary: "ID of the cron job to run",
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Running a cron job");
+        const { "cronjob-id": cronjobId } = this.args;
+        const cronjob = await p.runStep("getting cron job", async () => {
+            const r = await this.apiClient.cronjob.getCronjob({ cronjobId });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        const { id: executionId } = await p.runStep("running cron job", async () => {
+            const r = await this.apiClient.cronjob.createExecution({
+                cronjobId,
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        p.complete(_jsxs(Success, { children: ["An execution for cron job ", _jsx(Value, { children: cronjob.shortId }), " was successfully created. Execution ID: ", _jsx(Value, { children: executionId })] }));
+        return { executionId };
+    }
+    render({ executionId }) {
+        if (this.flags.quiet) {
+            return executionId;
+        }
+    }
+}

package/dist/esm/commands/cronjob/execution/abort.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    executionId: string;
+};
+export declare class Abort extends ExecRenderBaseCommand<typeof Abort, Result> {
+    static summary: string;
+    static flags: {
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        "execution-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ executionId }: Result): ReactNode;
+}
+export {};

package/dist/esm/commands/cronjob/execution/abort.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Args } from "@oclif/core";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import assertSuccess from "../../../lib/assert_success.js";
+export class Abort extends ExecRenderBaseCommand {
+    static summary = "Abort a running cron job execution.";
+    static flags = {
+        ...processFlags,
+    };
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cronjob the execution belongs to",
+            required: true,
+        }),
+        "execution-id": Args.string({
+            required: true,
+            description: "ID of the cron job execution to abort",
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Aborting a cron job execution");
+        const { "cronjob-id": cronjobId, "execution-id": executionId } = this.args;
+        await p.runStep("aborting cron job execution", async () => {
+            const r = await this.apiClient.cronjob.abortExecution({
+                cronjobId,
+                executionId,
+            });
+            assertSuccess(r);
+        });
+        p.complete(_jsxs(Success, { children: ["Execution ", _jsx(Value, { children: executionId }), " was successfully aborted."] }));
+        return { executionId };
+    }
+    render({ executionId }) {
+        if (this.flags.quiet) {
+            return executionId;
+        }
+    }
+}

package/dist/esm/commands/cronjob/execution/get.d.ts

@@ -0,0 +1,17 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["cronjob"]["getExecution"]>>;
+export declare class Get extends GetBaseCommand<typeof Get, APIResponse> {
+    static description: string;
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        "execution-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+}
+export {};

package/dist/esm/commands/cronjob/execution/get.js

@@ -0,0 +1,26 @@
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { Args } from "@oclif/core";
+export class Get extends GetBaseCommand {
+    static description = "Get a cron job execution.";
+    static aliases = ["project:cronjob:execution:get"];
+    static deprecateAliases = true;
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cronjob the execution belongs to",
+            required: true,
+        }),
+        "execution-id": Args.string({
+            description: "ID of the cronjob execution to be retrieved.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.cronjob.getExecution({
+            executionId: this.args["execution-id"],
+            cronjobId: this.args["cronjob-id"],
+        });
+    }
+}

package/dist/esm/commands/cronjob/execution/list.d.ts

@@ -0,0 +1,20 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../../types.js";
+import { ListColumns } from "../../../Formatter.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2CronjobsCronjobIdExecutions.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["cronjob"]["listExecutions"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    static args: {};
+    static flags: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.CronjobCronjobExecution[];
+    protected getColumns(): ListColumns<ResponseItem>;
+}
+export {};

package/dist/esm/commands/cronjob/execution/list.js

@@ -0,0 +1,41 @@
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { Flags } from "@oclif/core";
+import { formatRelativeDate } from "../../../lib/viewhelpers/date.js";
+export class List extends ListBaseCommand {
+    static description = "List CronjobExecutions belonging to a Cronjob.";
+    static aliases = ["project:cronjob:execution:list"];
+    static deprecateAliases = true;
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "cronjob-id": Flags.string({
+            description: "ID of the cron job for which to list executions for.",
+            required: true,
+            default: undefined,
+        }),
+    };
+    async getData() {
+        const { "cronjob-id": cronjobId } = this.flags;
+        return await this.apiClient.cronjob.listExecutions({ cronjobId });
+    }
+    mapData(data) {
+        return data;
+    }
+    getColumns() {
+        return {
+            id: {},
+            status: {},
+            duration: {
+                get: (r) => r.durationInMilliseconds
+                    ? Math.round(r.durationInMilliseconds / 1000) + "s"
+                    : "",
+            },
+            started: {
+                get: (r) => formatRelativeDate(r.executionStart),
+            },
+            ended: {
+                get: (r) => formatRelativeDate(r.executionEnd),
+            },
+        };
+    }
+}

package/dist/esm/commands/cronjob/execution/logs.d.ts

@@ -0,0 +1,17 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { BaseCommand } from "../../../BaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2CronjobsCronjobIdExecutionsExecutionId.Get.Parameters.Path;
+export declare class Logs extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    static flags: {
+        "no-pager": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        "execution-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/esm/commands/cronjob/execution/logs.js

@@ -0,0 +1,77 @@
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../BaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import * as cp from "child_process";
+import * as fs from "fs";
+import tempfile from "tempfile";
+export class Logs extends BaseCommand {
+    static summary = "Get the log output of a cronjob execution.";
+    static description = "This command prints the log output of a cronjob execution. " +
+        "" +
+        'When this command is run in a terminal, the output is piped through a pager. The pager is determined by your PAGER environment variable, with defaulting to "less". You can disable this behavior with the --no-pager flag.';
+    static aliases = ["project:cronjob:execution:logs"];
+    static deprecateAliases = true;
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+        "no-pager": Flags.boolean({
+            description: "Disable pager for output.",
+        }),
+    };
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cronjob the execution belongs to",
+            required: true,
+        }),
+        "execution-id": Args.string({
+            description: "ID of the cronjob execution to be retrieved.",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Logs);
+        const cronjobId = args["cronjob-id"];
+        const executionId = args["execution-id"];
+        const usePager = process.stdin.isTTY && !flags["no-pager"];
+        const cronJob = await this.apiClient.cronjob.getCronjob({
+            cronjobId,
+        });
+        const execution = await this.apiClient.cronjob.getExecution({
+            cronjobId,
+            executionId,
+        });
+        assertStatus(cronJob, 200);
+        assertStatus(execution, 200);
+        const projectId = cronJob.data.projectId;
+        if (!projectId) {
+            throw new Error("Cronjob has no project ID");
+        }
+        // TODO: Replace this with a call to the actual "getFileContent" method,
+        // once we support passing the required query parameters.
+        const response = await this.apiClient.axios.get(`/v2/projects/${projectId}/filesystem/files/raw`, {
+            params: {
+                file: execution.data.logPath,
+                inline: "true",
+            },
+        });
+        // await this.apiClient.projectFileSystem.getFileContent({
+        //    projectId ,
+        //   queryParameters: { file: execution.data.logPath, inline: true },
+        // });
+        if (usePager) {
+            const t = tempfile();
+            try {
+                fs.writeFileSync(t, response.data);
+                cp.spawnSync(process.env.PAGER || "less", [t], {
+                    stdio: "inherit",
+                });
+            }
+            finally {
+                fs.unlinkSync(t);
+            }
+        }
+        else {
+            this.log(response.data);
+        }
+    }
+}

package/dist/esm/commands/cronjob/get.d.ts

@@ -0,0 +1,14 @@
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { GetFormatter } from "../../Formatter.js";
+import { ReactNode } from "react";
+export declare class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    static args: {
+        "cronjob-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected formatter: GetFormatter;
+    protected render(): ReactNode;
+}

package/dist/esm/commands/cronjob/get.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+import { Args } from "@oclif/core";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { GetFormatter } from "../../Formatter.js";
+import { ComponentPrinter } from "../../rendering/react/ComponentPrinter.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { CronJobDetails } from "../../rendering/react/components/CronJob/CronJobDetails.js";
+export class Get extends RenderBaseCommand {
+    static description = "Get details of a cron job";
+    static flags = { ...GetBaseCommand.baseFlags };
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cron job to be retrieved.",
+            required: true,
+        }),
+    };
+    formatter = new GetFormatter(new ComponentPrinter((r) => _jsx(CronJobDetails, { cronjob: r })));
+    render() {
+        const { "cronjob-id": cronjobId } = this.args;
+        const cronjobResponse = usePromise((cronjobId) => this.apiClient.cronjob.getCronjob({ cronjobId }), [cronjobId]);
+        assertStatus(cronjobResponse, 200);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "cronjob", data: cronjobResponse.data });
+        }
+        return _jsx(CronJobDetails, { cronjob: cronjobResponse.data });
+    }
+}