hereya-cli 0.101.0 → 0.102.0

package/dist/backend/cloud/cloud-backend/executor-jobs.d.ts

@@ -1,4 +1,15 @@
 import { CloudHttpConfig } from './utils.js';
+export declare function cancelExecutorJob(config: CloudHttpConfig, input: {
+    jobId: string;
+    workspace: string;
+}): Promise<{
+    reason: string;
+    status?: string;
+    success: false;
+} | {
+    status: string;
+    success: true;
+}>;
 export declare function generateExecutorToken(config: CloudHttpConfig, input: {
     workspace: string;
 }): Promise<{
@@ -27,6 +38,25 @@ export declare function getExecutorJobStatus(config: CloudHttpConfig, input: {
     reason: string;
     success: false;
 }>;
+export declare function listExecutorJobs(config: CloudHttpConfig, input: {
+    limit?: number;
+    status?: string;
+    workspace: string;
+}): Promise<{
+    jobs: Array<{
+        attempts: number;
+        claimedBy: null | string;
+        createdAt: string;
+        id: string;
+        status: string;
+        type: string;
+        updatedAt: string;
+    }>;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
 export declare function pollExecutorJobs(config: CloudHttpConfig, input: {
     executorId?: string;
     workspace: string;
@@ -58,6 +88,15 @@ export declare function revokeExecutorToken(config: CloudHttpConfig, input: {
 } | {
     success: true;
 }>;
+export declare function rewakeExecutorJob(config: CloudHttpConfig, input: {
+    jobId: string;
+    workspace: string;
+}): Promise<{
+    reason?: string;
+    rewoken?: boolean;
+    status?: string;
+    success: boolean;
+}>;
 export declare function submitExecutorJob(config: CloudHttpConfig, input: {
     payload: object;
     type: 'app-deploy' | 'app-destroy' | 'deploy' | 'destroy' | 'provision' | 'resolve-env' | 'undeploy';

package/dist/backend/cloud/cloud-backend/executor-jobs.js

@@ -1,4 +1,20 @@
 import { safeResponseJson } from './utils.js';
+export async function cancelExecutorJob(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs/${encodeURIComponent(input.jobId)}/cancel`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return {
+            reason: error.error || `Failed to cancel job (status ${response.status})`,
+            status: error.status,
+            success: false,
+        };
+    }
+    const result = await response.json();
+    return { status: result.status, success: true };
+}
 export async function generateExecutorToken(config, input) {
     const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
         headers: { 'Authorization': `Bearer ${config.accessToken}` },
@@ -33,6 +49,25 @@ export async function getExecutorJobStatus(config, input) {
     const result = await response.json();
     return { job: result.job, success: true };
 }
+export async function listExecutorJobs(config, input) {
+    const url = new URL(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs`);
+    if (input.limit !== undefined) {
+        url.searchParams.set('limit', String(input.limit));
+    }
+    if (input.status) {
+        url.searchParams.set('status', input.status);
+    }
+    const response = await fetch(url.toString(), {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to list jobs', success: false };
+    }
+    const result = await response.json();
+    return { jobs: result.jobs, success: true };
+}
 export async function pollExecutorJobs(config, input) {
     const url = new URL(`${config.url}/api/executor/jobs`);
     url.searchParams.set('workspace', input.workspace);
@@ -75,6 +110,29 @@ export async function revokeExecutorToken(config, input) {
     }
     return { success: true };
 }
+export async function rewakeExecutorJob(config, input) {
+    try {
+        const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs/${encodeURIComponent(input.jobId)}/rewake`, {
+            body: JSON.stringify({}),
+            headers: { 'Authorization': `Bearer ${config.accessToken}`, 'Content-Type': 'application/json' },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const error = await safeResponseJson(response);
+            return { reason: error.error || `Rewake failed with status ${response.status}`, success: false };
+        }
+        const result = await safeResponseJson(response);
+        return {
+            reason: result.reason,
+            rewoken: result.rewoken,
+            status: result.status,
+            success: Boolean(result.success),
+        };
+    }
+    catch (error) {
+        return { reason: error instanceof Error ? error.message : String(error), success: false };
+    }
+}
 export async function submitExecutorJob(config, input) {
     const formData = new FormData();
     formData.append('type', input.type);

package/dist/backend/cloud/cloud-backend.d.ts

@@ -27,6 +27,17 @@ export declare class CloudBackend implements Backend {
     private readonly config;
     constructor(config: CloudBackendConfig);
     addPackageToWorkspace(input: Parameters<typeof packagesWorkspace.addPackageToWorkspace>[1]): Promise<import("../common.js").AddPackageToWorkspaceOutput>;
+    cancelExecutorJob(input: {
+        jobId: string;
+        workspace: string;
+    }): Promise<{
+        reason: string;
+        status?: string;
+        success: false;
+    } | {
+        status: string;
+        success: true;
+    }>;
     createWorkspace(input: Parameters<typeof workspaces.createWorkspace>[1]): Promise<import("../common.js").CreateWorkspaceOutput>;
     deleteState(input: Parameters<typeof state.deleteState>[1]): Promise<import("../common.js").DeleteStateOutput>;
     deleteWorkspace(input: Parameters<typeof workspaces.deleteWorkspace>[1]): Promise<import("../common.js").DeleteWorkspaceOutput>;
@@ -124,6 +135,25 @@ export declare class CloudBackend implements Backend {
         success: true;
         versions: appsVersions.AppVersionSummary[];
     }>;
+    listExecutorJobs(input: {
+        limit?: number;
+        status?: string;
+        workspace: string;
+    }): Promise<{
+        jobs: Array<{
+            attempts: number;
+            claimedBy: null | string;
+            createdAt: string;
+            id: string;
+            status: string;
+            type: string;
+            updatedAt: string;
+        }>;
+        success: true;
+    } | {
+        reason: string;
+        success: false;
+    }>;
     listPackageVersions(name: string): Promise<import("../common.js").ListPackageVersionsOutput>;
     listProjects(): Promise<import("../common.js").ListProjectsOutput>;
     listWorkspaces(input?: Parameters<typeof workspaces.listWorkspaces>[1]): Promise<string[]>;
@@ -162,6 +192,15 @@ export declare class CloudBackend implements Backend {
     } | {
         success: true;
     }>;
+    rewakeExecutorJob(input: {
+        jobId: string;
+        workspace: string;
+    }): Promise<{
+        reason?: string;
+        rewoken?: boolean;
+        status?: string;
+        success: boolean;
+    }>;
     saveProjectMetadata(input: Parameters<typeof projects.saveProjectMetadata>[1]): Promise<import("../common.js").SaveProjectMetadataOutput>;
     saveState(config: Config, workspace?: string): Promise<void>;
     searchPackages(input: Parameters<typeof packagesRegistry.searchPackages>[1]): Promise<import("../common.js").SearchPackagesOutput>;

package/dist/backend/cloud/cloud-backend.js

@@ -18,6 +18,9 @@ export class CloudBackend {
     addPackageToWorkspace(input) {
         return packagesWorkspace.addPackageToWorkspace(this.config, input);
     }
+    cancelExecutorJob(input) {
+        return executorJobs.cancelExecutorJob(this.config, input);
+    }
     createWorkspace(input) {
         return workspaces.createWorkspace(this.config, input);
     }
@@ -90,6 +93,9 @@ export class CloudBackend {
     listAppVersions(name) {
         return appsVersions.listAppVersions(this.config, name);
     }
+    listExecutorJobs(input) {
+        return executorJobs.listExecutorJobs(this.config, input);
+    }
     listPackageVersions(name) {
         return packagesRegistry.listPackageVersions(this.config, name);
     }
@@ -120,6 +126,9 @@ export class CloudBackend {
     revokeExecutorToken(input) {
         return executorJobs.revokeExecutorToken(this.config, input);
     }
+    rewakeExecutorJob(input) {
+        return executorJobs.rewakeExecutorJob(this.config, input);
+    }
     saveProjectMetadata(input) {
         return projects.saveProjectMetadata(this.config, input);
     }

package/dist/commands/job/cancel/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class JobCancel extends Command {
+    static args: {
+        jobId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/job/cancel/index.js

@@ -0,0 +1,31 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class JobCancel extends Command {
+    static args = {
+        jobId: Args.string({ description: 'id of the remote executor job to cancel', required: true }),
+    };
+    static description = 'Cancel a pending remote executor job. Only pending jobs can be cancelled.';
+    static examples = ['<%= config.bin %> <%= command.id %> my-job-id -w my-workspace'];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace the job belongs to',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(JobCancel);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Cancelling executor jobs requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.cancelExecutorJob({ jobId: args.jobId, workspace: flags.workspace });
+        if (!result.success) {
+            const detail = result.status && !result.reason.includes(result.status) ? ` (current status: ${result.status})` : '';
+            this.error(`Failed to cancel job ${args.jobId}: ${result.reason}${detail}`);
+        }
+        this.log(`Job ${args.jobId} cancelled.`);
+    }
+}

package/dist/commands/job/list/index.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class JobList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/job/list/index.js

@@ -0,0 +1,54 @@
+import { Command, Flags } from '@oclif/core';
+import { CloudBackend } from '../../../backend/cloud/cloud-backend.js';
+import { getBackend } from '../../../backend/index.js';
+export default class JobList extends Command {
+    static description = 'List remote executor jobs for a workspace, newest first. Pending jobs can be cancelled with `hereya job cancel <jobId>`.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -w my-workspace',
+        '<%= config.bin %> <%= command.id %> -w my-workspace --status pending --limit 10',
+    ];
+    static flags = {
+        limit: Flags.integer({
+            description: 'maximum number of jobs to list (server default: 20)',
+            required: false,
+        }),
+        status: Flags.string({
+            description: 'only list jobs with this status',
+            options: ['pending', 'running', 'completed', 'failed', 'cancelled'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to list jobs for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(JobList);
+        const backend = await getBackend();
+        if (!(backend instanceof CloudBackend)) {
+            this.error('Listing executor jobs requires the cloud backend. Run `hereya login` first.');
+        }
+        const cloudBackend = backend;
+        const result = await cloudBackend.listExecutorJobs({
+            limit: flags.limit,
+            status: flags.status,
+            workspace: flags.workspace,
+        });
+        if (!result.success) {
+            this.error(`Failed to list jobs: ${result.reason}`);
+        }
+        if (result.jobs.length === 0) {
+            this.log(`No jobs found for workspace ${flags.workspace}.`);
+            return;
+        }
+        const idWidth = Math.max(2, ...result.jobs.map((j) => j.id.length));
+        const typeWidth = Math.max(4, ...result.jobs.map((j) => j.type.length));
+        const statusWidth = Math.max(6, ...result.jobs.map((j) => j.status.length));
+        this.log(`${'Id'.padEnd(idWidth)}  ${'Type'.padEnd(typeWidth)}  ${'Status'.padEnd(statusWidth)}  Created`);
+        this.log('-'.repeat(idWidth + typeWidth + statusWidth + 13));
+        for (const job of result.jobs) {
+            this.log(`${job.id.padEnd(idWidth)}  ${job.type.padEnd(typeWidth)}  ${job.status.padEnd(statusWidth)}  ${new Date(job.createdAt).toLocaleString()}`);
+        }
+    }
+}

package/dist/lib/remote-job-utils.js

@@ -1,5 +1,16 @@
 const DEFAULT_TIMEOUT_MIN = 90;
 const HEARTBEAT_INTERVAL_MS = 5 * 60 * 1000;
+/**
+ * How often, while a job is still `pending`, the CLI asks hereya-cloud to
+ * re-fire the executor wake. Guards against a wake being swallowed because the
+ * ephemeral executor was idle-draining when the job was created.
+ */
+const REWAKE_INTERVAL_MS = 60_000;
+/**
+ * Grace period before the first re-wake, giving the original creation-time wake
+ * a chance to land before we ask for another one.
+ */
+const REWAKE_INITIAL_DELAY_MS = 60_000;
 /**
  * Default poll timeout, in ms. Overridable via HEREYA_JOB_TIMEOUT_MIN env var
  * (positive integer, in minutes). Falls back to DEFAULT_TIMEOUT_MIN.
@@ -14,14 +25,39 @@ function defaultTimeoutMs() {
     }
     return DEFAULT_TIMEOUT_MIN * 60 * 1000;
 }
+/**
+ * While a job is still `pending` (not yet claimed by any executor), periodically
+ * ask hereya-cloud to re-fire the executor wake. Recovers from a creation-time
+ * wake being swallowed by an idle-draining ephemeral executor. Any failure is
+ * non-fatal — the caller keeps polling regardless. Returns the (possibly
+ * updated) `lastRewakeAt` timestamp.
+ */
+async function maybeRewake(args) {
+    const { cloudBackend, jobId, lastRewakeAt, logger, startTime, status, workspace } = args;
+    if (status !== 'pending') {
+        return lastRewakeAt;
+    }
+    const now = Date.now();
+    if (now - startTime < REWAKE_INITIAL_DELAY_MS || now - lastRewakeAt < REWAKE_INTERVAL_MS) {
+        return lastRewakeAt;
+    }
+    try {
+        await cloudBackend.rewakeExecutorJob({ jobId, workspace });
+    }
+    catch (error) {
+        logger?.debug?.(`Re-wake request failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return now;
+}
 export async function pollExecutorJob(input) {
     const { cloudBackend, jobId, logger, workspace } = input;
     const timeout = input.timeoutMs ?? defaultTimeoutMs();
-    logger?.info?.(`Remote executor job submitted (${jobId}). Waiting for result...`);
+    logger?.info?.(`Remote executor job submitted (${jobId}). Waiting for result... Cancel with: hereya job cancel ${jobId} -w ${workspace}`);
     const startTime = Date.now();
     let lastLogLength = 0;
     let lastStatus = 'pending';
     let lastUserHeartbeat = startTime;
+    let lastRewakeAt = startTime;
     while (Date.now() - startTime < timeout) {
         // eslint-disable-next-line no-await-in-loop
         const statusResult = await cloudBackend.getExecutorJobStatus({
@@ -53,6 +89,16 @@ export async function pollExecutorJob(input) {
                 lastUserHeartbeat = now;
             }
         }
+        // eslint-disable-next-line no-await-in-loop
+        lastRewakeAt = await maybeRewake({
+            cloudBackend,
+            jobId,
+            lastRewakeAt,
+            logger,
+            startTime,
+            status: job.status,
+            workspace,
+        });
         if (job.status === 'completed') {
             if (job.result) {
                 return { result: job.result, success: true };
@@ -63,6 +109,9 @@ export async function pollExecutorJob(input) {
             const reason = job.result?.reason || 'Remote executor job failed';
             return { reason, success: false };
         }
+        if (job.status === 'cancelled') {
+            return { reason: 'Job was cancelled', success: false };
+        }
         // Small delay between polls (server-side long polling handles most of the wait)
         // eslint-disable-next-line no-await-in-loop
         await new Promise(resolve => {