mcoda 0.1.0

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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,44 @@
+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 });
+  }
+});