mcoda 0.1.2 → 0.1.4

package/packages/core/src/services/jobs/JobsApiClient.ts

@@ -1,113 +0,0 @@
-import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
-
-export interface JobsApiJob {
-  id: string;
-  type: string;
-  command_name?: string;
-  job_state?: string;
-  job_state_detail?: string;
-  job_state_detail_code?: string;
-  total_units?: number | null;
-  completed_units?: number | null;
-  created_at?: string;
-  updated_at?: string;
-  last_checkpoint_at?: string;
-  completed_at?: string | null;
-  payload_json?: unknown;
-}
-
-export interface JobsApiLogs {
-  entries: Array<{
-    timestamp: string;
-    sequence?: number | null;
-    level?: string | null;
-    source?: string | null;
-    message?: string | null;
-    task_id?: string | null;
-    task_key?: string | null;
-    phase?: string | null;
-    details?: Record<string, unknown> | null;
-  }>;
-  cursor?: { timestamp: string; sequence?: number | null };
-}
-
-export interface JobsApiTasksSummary {
-  totals: Record<string, number>;
-  tasks: Array<{
-    task_id?: string | null;
-    task_key?: string | null;
-    status?: string | null;
-    started_at?: string | null;
-    finished_at?: string | null;
-    command?: string | null;
-  }>;
-}
-
-export class JobsApiClient {
-  constructor(private workspace: WorkspaceResolution, private baseUrl: string) {}
-
-  private async fetchJson<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T | undefined> {
-    try {
-      const url = new URL(path, this.baseUrl);
-      if (query) {
-        Object.entries(query).forEach(([key, value]) => {
-          if (value === undefined) return;
-          url.searchParams.set(key, String(value));
-        });
-      }
-      const resp = await fetch(url.toString(), { headers: { accept: "application/json" } });
-      if (!resp.ok) return undefined;
-      return (await resp.json()) as T;
-    } catch {
-      return undefined;
-    }
-  }
-
-  private async postJson<T>(path: string, body?: Record<string, unknown>): Promise<T | undefined> {
-    try {
-      const resp = await fetch(new URL(path, this.baseUrl), {
-        method: "POST",
-        headers: { "content-type": "application/json", accept: "application/json" },
-        body: body ? JSON.stringify(body) : undefined,
-      });
-      if (!resp.ok) return undefined;
-      return (await resp.json()) as T;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async listJobs(params: { status?: string; type?: string; project?: string; since?: string; limit?: number }): Promise<JobsApiJob[] | undefined> {
-    return this.fetchJson<JobsApiJob[]>("/jobs", params as any);
-  }
-
-  async getJob(jobId: string): Promise<JobsApiJob | undefined> {
-    return this.fetchJson<JobsApiJob>(`/jobs/${jobId}`);
-  }
-
-  async getCheckpoint(jobId: string): Promise<Record<string, unknown> | undefined> {
-    return this.fetchJson<Record<string, unknown>>(`/jobs/${jobId}/checkpoint`);
-  }
-
-  async getLogs(jobId: string, params: { since?: string; after?: { timestamp: string; sequence?: number | null } }): Promise<JobsApiLogs | undefined> {
-    const sequence =
-      params.after && typeof params.after.sequence === "number" ? params.after.sequence : undefined;
-    const after = params.after?.timestamp;
-    return this.fetchJson<JobsApiLogs>(`/jobs/${jobId}/logs`, {
-      since: params.since,
-      after: after || undefined,
-      sequence,
-    });
-  }
-
-  async getTasksSummary(jobId: string): Promise<JobsApiTasksSummary | undefined> {
-    return this.fetchJson<JobsApiTasksSummary>(`/jobs/${jobId}/tasks/summary`);
-  }
-
-  async cancelJob(jobId: string, options: { force?: boolean; reason?: string } = {}): Promise<void> {
-    await this.postJson(`/jobs/${jobId}/cancel`, {
-      force: options.force ?? false,
-      reason: options.reason ?? (options.force ? "force" : "user"),
-    });
-  }
-}

package/packages/core/src/services/jobs/__tests__/JobInsightsService.test.ts

@@ -1,17 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
-import { JobInsightsService } from "../JobInsightsService.js";
-
-describe("JobInsightsService", () => {
-  it("fails without a configured jobs API", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-jobinsights-"));
-    const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
-    const service = new JobInsightsService(workspace, { close: async () => {} } as any, undefined);
-    await assert.rejects(() => service.listJobs(), /Jobs API is not configured/);
-    await fs.rm(dir, { recursive: true, force: true });
-  });
-});

package/packages/core/src/services/jobs/__tests__/JobResumeService.test.ts

@@ -1,45 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
-import { JobResumeService } from "../JobResumeService.js";
-
-describe("JobResumeService", () => {
-  it("throws when job is missing", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-resume-"));
-    const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
-    const service = new JobResumeService(workspace, {
-      getJob: async () => undefined,
-      readCheckpoints: async () => [],
-      updateJobStatus: async () => {},
-    } as any);
-    await assert.rejects(() => service.resume("job-1"), /Job not found/);
-    await fs.rm(dir, { recursive: true, force: true });
-  });
-
-  it("rejects resume without checkpoints", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-resume-"));
-    const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
-    const service = new JobResumeService(workspace, {
-      getJob: async () => ({ id: "job-1", state: "failed" }),
-      readCheckpoints: async () => [],
-      updateJobStatus: async () => {},
-    } as any);
-    await assert.rejects(() => service.resume("job-1"), /No checkpoints/);
-    await fs.rm(dir, { recursive: true, force: true });
-  });
-
-  it("rejects completed jobs", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-resume-"));
-    const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
-    const service = new JobResumeService(workspace, {
-      getJob: async () => ({ id: "job-1", state: "completed" }),
-      readCheckpoints: async () => [{ stage: "done", timestamp: new Date().toISOString() }],
-      updateJobStatus: async () => {},
-    } as any);
-    await assert.rejects(() => service.resume("job-1"), /cannot resume/);
-    await fs.rm(dir, { recursive: true, force: true });
-  });
-});

package/packages/core/src/services/jobs/__tests__/JobService.test.ts

@@ -1,44 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { JobService } from "../JobService.js";
-
-test("JobService writes command runs, jobs, and checkpoints in JSON mode", async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-jobservice-"));
-  const previous = process.env.MCODA_DISABLE_DB;
-  process.env.MCODA_DISABLE_DB = "1";
-  try {
-    const service = new JobService(dir);
-    const commandRun = await service.startCommandRun("work-on-tasks", "proj", { taskIds: ["t1"] });
-    assert.ok(commandRun.id);
-
-    const job = await service.startJob("work", commandRun.id, "proj", {
-      commandName: "work-on-tasks",
-      totalItems: 2,
-      processedItems: 0,
-    });
-    assert.ok(job.id);
-
-    await service.updateJobStatus(job.id, "running", { processedItems: 1, lastCheckpoint: "halfway" });
-    await service.writeCheckpoint(job.id, { stage: "halfway", timestamp: new Date().toISOString() });
-
-    const checkpoints = await service.readCheckpoints(job.id);
-    assert.equal(checkpoints.length, 1);
-
-    const manifestPath = path.join(dir, ".mcoda", "jobs", job.id, "manifest.json");
-    const manifestExists = await fs
-      .stat(manifestPath)
-      .then(() => true)
-      .catch(() => false);
-    assert.equal(manifestExists, true);
-  } finally {
-    if (previous === undefined) {
-      delete process.env.MCODA_DISABLE_DB;
-    } else {
-      process.env.MCODA_DISABLE_DB = previous;
-    }
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-});