@dobby.ai/dobby 0.1.1 → 0.1.2

package/src/cron/schedule.ts

@@ -1,61 +0,0 @@
-import { CronExpressionParser } from "cron-parser";
-import type { JobSchedule } from "./types.js";
-
-const BACKOFF_STEPS_MS = [30_000, 60_000, 5 * 60_000, 15 * 60_000] as const;
-
-function parseAtTimestamp(at: string): number {
-  const timestamp = Date.parse(at);
-  if (!Number.isFinite(timestamp)) {
-    throw new Error(`Invalid at schedule timestamp '${at}'`);
-  }
-  return timestamp;
-}
-
-function nextCronAtMs(expr: string, currentDateMs: number, tz?: string): number {
-  const parsed = CronExpressionParser.parse(expr, {
-    currentDate: new Date(currentDateMs),
-    ...(tz ? { tz } : {}),
-  });
-  return parsed.next().toDate().getTime();
-}
-
-export function computeInitialNextRunAtMs(schedule: JobSchedule, nowMs: number): number | undefined {
-  if (schedule.kind === "at") {
-    return parseAtTimestamp(schedule.at);
-  }
-
-  if (schedule.kind === "every") {
-    return nowMs + schedule.everyMs;
-  }
-
-  return nextCronAtMs(schedule.expr, nowMs, schedule.tz);
-}
-
-export function computeNextRunAfterSuccessMs(schedule: JobSchedule, nowMs: number): number | undefined {
-  if (schedule.kind === "at") {
-    return undefined;
-  }
-
-  if (schedule.kind === "every") {
-    return nowMs + schedule.everyMs;
-  }
-
-  return nextCronAtMs(schedule.expr, nowMs, schedule.tz);
-}
-
-export function computeBackoffDelayMs(consecutiveErrors: number): number {
-  const safeErrors = Number.isFinite(consecutiveErrors) && consecutiveErrors > 0 ? Math.floor(consecutiveErrors) : 1;
-  const index = Math.min(safeErrors - 1, BACKOFF_STEPS_MS.length - 1);
-  const fallback = BACKOFF_STEPS_MS[BACKOFF_STEPS_MS.length - 1] as number;
-  return BACKOFF_STEPS_MS[index] ?? fallback;
-}
-
-export function describeSchedule(schedule: JobSchedule): string {
-  if (schedule.kind === "at") {
-    return `at ${schedule.at}`;
-  }
-  if (schedule.kind === "every") {
-    return `every ${schedule.everyMs}ms`;
-  }
-  return schedule.tz ? `cron '${schedule.expr}' (tz=${schedule.tz})` : `cron '${schedule.expr}'`;
-}

package/src/cron/service.ts

@@ -1,249 +0,0 @@
-import type { Gateway } from "../core/gateway.js";
-import type { GatewayLogger } from "../core/types.js";
-import { computeBackoffDelayMs, computeInitialNextRunAtMs, computeNextRunAfterSuccessMs } from "./schedule.js";
-import { CronStore } from "./store.js";
-import type { CronConfig, CronRunLogRecord, ScheduledJob } from "./types.js";
-
-interface CronServiceOptions {
-  config: CronConfig;
-  store: CronStore;
-  gateway: Gateway;
-  logger: GatewayLogger;
-}
-
-interface ScheduledRunContext {
-  runId: string;
-  jobId: string;
-  scheduledAtMs: number;
-}
-
-export class CronService {
-  private timer: NodeJS.Timeout | null = null;
-  private readonly activeRuns = new Map<string, Promise<void>>();
-  private tickInFlight = false;
-  private started = false;
-  private stopping = false;
-
-  constructor(private readonly options: CronServiceOptions) {}
-
-  async start(): Promise<void> {
-    if (this.started) {
-      return;
-    }
-
-    await this.options.store.load();
-    await this.recoverOnStartup();
-
-    if (!this.options.config.enabled) {
-      this.options.logger.info("Cron scheduler is disabled by config");
-      this.started = true;
-      return;
-    }
-
-    const intervalMs = Math.min(this.options.config.pollIntervalMs, 60_000);
-    await this.tick();
-    this.timer = setInterval(() => {
-      void this.tick();
-    }, intervalMs);
-
-    this.started = true;
-    this.options.logger.info(
-      {
-        pollIntervalMs: intervalMs,
-        maxConcurrentRuns: this.options.config.maxConcurrentRuns,
-      },
-      "Cron scheduler started",
-    );
-  }
-
-  async stop(): Promise<void> {
-    this.stopping = true;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-
-    await Promise.allSettled(this.activeRuns.values());
-    this.activeRuns.clear();
-    this.started = false;
-  }
-
-  async triggerNow(jobId: string): Promise<void> {
-    await this.options.store.load();
-    const job = this.options.store.getJob(jobId);
-    if (!job) {
-      throw new Error(`Cron job '${jobId}' does not exist`);
-    }
-
-    await this.enqueueJob(job, Date.now());
-    const latestRun = [...this.activeRuns.values()].at(-1);
-    if (latestRun) {
-      await latestRun;
-    }
-  }
-
-  private async recoverOnStartup(): Promise<void> {
-    const now = Date.now();
-    for (const job of this.options.store.listJobs()) {
-      let changed = false;
-      const next = structuredClone(job);
-
-      if (next.state.runningAtMs !== undefined) {
-        next.state.runningAtMs = undefined;
-        next.state.lastStatus = "error";
-        next.state.lastError = "Recovered stale running state after restart";
-        changed = true;
-      }
-
-      if (next.state.nextRunAtMs === undefined) {
-        next.state.nextRunAtMs = computeInitialNextRunAtMs(next.schedule, now);
-        changed = true;
-      }
-
-      if (
-        this.options.config.runMissedOnStartup
-        && next.enabled
-        && next.state.nextRunAtMs !== undefined
-        && next.state.nextRunAtMs <= now
-      ) {
-        next.state.nextRunAtMs = now;
-        changed = true;
-      }
-
-      if (changed) {
-        next.updatedAtMs = now;
-        await this.options.store.upsertJob(next);
-      }
-    }
-  }
-
-  private async tick(): Promise<void> {
-    if (this.stopping || !this.options.config.enabled) {
-      return;
-    }
-    if (this.tickInFlight) {
-      return;
-    }
-
-    this.tickInFlight = true;
-    try {
-      // Reload from disk on every tick so CLI mutations (cron run/update/pause/resume)
-      // made by a separate process become visible to the long-running scheduler.
-      await this.options.store.load();
-
-      const now = Date.now();
-      const dueJobs = this.options.store.listJobs().filter((job) =>
-        job.enabled
-        && job.state.runningAtMs === undefined
-        && job.state.nextRunAtMs !== undefined
-        && job.state.nextRunAtMs <= now
-      );
-
-      for (const job of dueJobs) {
-        if (this.activeRuns.size >= this.options.config.maxConcurrentRuns) {
-          break;
-        }
-        await this.enqueueJob(job, now);
-      }
-    } finally {
-      this.tickInFlight = false;
-    }
-  }
-
-  private async enqueueJob(job: ScheduledJob, now: number): Promise<void> {
-    const scheduledAtMs = job.state.nextRunAtMs ?? now;
-    const runContext: ScheduledRunContext = {
-      runId: `${job.id}:${scheduledAtMs}`,
-      jobId: job.id,
-      scheduledAtMs,
-    };
-
-    await this.options.store.updateJob(job.id, (current) => ({
-      ...current,
-      updatedAtMs: now,
-      state: {
-        ...current.state,
-        runningAtMs: now,
-      },
-    }));
-
-    const runPromise = this.executeJobRun(runContext)
-      .catch((error) => {
-        this.options.logger.warn(
-          { err: error, jobId: runContext.jobId, runId: runContext.runId },
-          "Cron run failed",
-        );
-      })
-      .finally(() => {
-        this.activeRuns.delete(runContext.runId);
-      });
-
-    this.activeRuns.set(runContext.runId, runPromise);
-  }
-
-  private async executeJobRun(run: ScheduledRunContext): Promise<void> {
-    const startedAtMs = Date.now();
-    const job = this.options.store.getJob(run.jobId);
-    if (!job) {
-      return;
-    }
-
-    let status: CronRunLogRecord["status"] = "ok";
-    let errorMessage: string | undefined;
-
-    try {
-      await this.options.gateway.handleScheduled({
-        jobId: job.id,
-        runId: run.runId,
-        prompt: job.prompt,
-        connectorId: job.delivery.connectorId,
-        routeId: job.delivery.routeId,
-        channelId: job.delivery.channelId,
-        ...(job.delivery.threadId ? { threadId: job.delivery.threadId } : {}),
-        timeoutMs: this.options.config.jobTimeoutMs,
-      });
-    } catch (error) {
-      status = "error";
-      errorMessage = error instanceof Error ? error.message : String(error);
-    }
-
-    const endedAtMs = Date.now();
-    await this.options.store.updateJob(job.id, (current) => {
-      const isSuccess = status === "ok";
-      const previousErrors = current.state.consecutiveErrors ?? 0;
-      const nextErrorCount = isSuccess ? 0 : previousErrors + 1;
-
-      const nextRunAtMs = isSuccess
-        ? computeNextRunAfterSuccessMs(current.schedule, endedAtMs)
-        : current.schedule.kind === "at"
-          ? undefined
-          : endedAtMs + computeBackoffDelayMs(nextErrorCount);
-
-      return {
-        ...current,
-        enabled: current.schedule.kind === "at" ? false : current.enabled,
-        updatedAtMs: endedAtMs,
-        state: {
-          ...current.state,
-          runningAtMs: undefined,
-          lastRunAtMs: endedAtMs,
-          lastStatus: isSuccess ? "ok" : "error",
-          lastError: isSuccess ? undefined : errorMessage,
-          consecutiveErrors: nextErrorCount,
-          nextRunAtMs,
-        },
-      };
-    });
-
-    const runRecord: CronRunLogRecord = {
-      runId: run.runId,
-      jobId: job.id,
-      jobName: job.name,
-      startedAtMs,
-      endedAtMs,
-      status,
-      ...(errorMessage ? { error: errorMessage } : {}),
-    };
-    await this.options.store.appendRunLog(runRecord);
-  }
-}

package/src/cron/store.ts

@@ -1,155 +0,0 @@
-import { access, appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { z } from "zod";
-import type { GatewayLogger } from "../core/types.js";
-import type { CronJobsSnapshot, CronRunLogRecord, JobSchedule, ScheduledJob } from "./types.js";
-
-const jobScheduleSchema: z.ZodType<JobSchedule> = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("at"),
-    at: z.string().min(1),
-  }),
-  z.object({
-    kind: z.literal("every"),
-    everyMs: z.number().int().positive(),
-  }),
-  z.object({
-    kind: z.literal("cron"),
-    expr: z.string().min(1),
-    tz: z.string().min(1).optional(),
-  }),
-]);
-
-const scheduledJobSchema: z.ZodType<ScheduledJob> = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  enabled: z.boolean(),
-  schedule: jobScheduleSchema,
-  sessionPolicy: z.enum(["stateless", "shared-session"]).optional(),
-  prompt: z.string(),
-  delivery: z.object({
-    connectorId: z.string().min(1),
-    routeId: z.string().min(1),
-    channelId: z.string().min(1),
-    threadId: z.string().min(1).optional(),
-  }),
-  createdAtMs: z.number().int().nonnegative(),
-  updatedAtMs: z.number().int().nonnegative(),
-  state: z.object({
-    nextRunAtMs: z.number().int().nonnegative().optional(),
-    runningAtMs: z.number().int().nonnegative().optional(),
-    lastRunAtMs: z.number().int().nonnegative().optional(),
-    lastStatus: z.enum(["ok", "error", "skipped"]).optional(),
-    lastError: z.string().optional(),
-    consecutiveErrors: z.number().int().nonnegative().optional(),
-  }),
-});
-
-const snapshotSchema = z.object({
-  version: z.literal(1),
-  jobs: z.array(scheduledJobSchema),
-});
-
-function cloneJob(job: ScheduledJob): ScheduledJob {
-  return structuredClone(job);
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function writeAtomic(filePath: string, payload: string): Promise<void> {
-  await mkdir(dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  await writeFile(tempPath, payload, "utf-8");
-  await rename(tempPath, filePath);
-}
-
-export class CronStore {
-  private readonly jobs = new Map<string, ScheduledJob>();
-
-  constructor(
-    private readonly jobsFilePath: string,
-    private readonly runLogFilePath: string,
-    private readonly logger: GatewayLogger,
-  ) {}
-
-  async load(): Promise<void> {
-    this.jobs.clear();
-    const absolutePath = resolve(this.jobsFilePath);
-    if (await fileExists(absolutePath)) {
-      try {
-        const raw = await readFile(absolutePath, "utf-8");
-        const parsed = snapshotSchema.parse(JSON.parse(raw));
-        for (const job of parsed.jobs) {
-          this.jobs.set(job.id, job);
-        }
-      } catch (error) {
-        this.logger.warn({ err: error, filePath: absolutePath }, "Failed to load cron jobs store; starting empty");
-      }
-    }
-  }
-
-  listJobs(): ScheduledJob[] {
-    return [...this.jobs.values()]
-      .map((job) => cloneJob(job))
-      .sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id));
-  }
-
-  getJob(jobId: string): ScheduledJob | null {
-    const found = this.jobs.get(jobId);
-    return found ? cloneJob(found) : null;
-  }
-
-  async upsertJob(job: ScheduledJob): Promise<void> {
-    const normalized = scheduledJobSchema.parse(job);
-    this.jobs.set(normalized.id, cloneJob(normalized));
-    await this.flush();
-  }
-
-  async updateJob(jobId: string, updater: (current: ScheduledJob) => ScheduledJob): Promise<ScheduledJob> {
-    const current = this.jobs.get(jobId);
-    if (!current) {
-      throw new Error(`Cron job '${jobId}' does not exist`);
-    }
-
-    const next = scheduledJobSchema.parse(updater(cloneJob(current)));
-    this.jobs.set(jobId, cloneJob(next));
-    await this.flush();
-    return cloneJob(next);
-  }
-
-  async removeJob(jobId: string): Promise<boolean> {
-    const deleted = this.jobs.delete(jobId);
-    if (!deleted) {
-      return false;
-    }
-    await this.flush();
-    return true;
-  }
-
-  async appendRunLog(record: CronRunLogRecord): Promise<void> {
-    const line = `${JSON.stringify(record)}\n`;
-    try {
-      await mkdir(dirname(this.runLogFilePath), { recursive: true });
-      await appendFile(this.runLogFilePath, line, "utf-8");
-    } catch (error) {
-      this.logger.warn({ err: error, runLogFilePath: this.runLogFilePath }, "Failed to append cron run log");
-    }
-  }
-
-  private async flush(): Promise<void> {
-    const snapshot: CronJobsSnapshot = {
-      version: 1,
-      jobs: [...this.jobs.values()]
-        .map((job) => cloneJob(job))
-        .sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id)),
-    };
-    await writeAtomic(this.jobsFilePath, `${JSON.stringify(snapshot, null, 2)}\n`);
-  }
-}

package/src/cron/types.ts

@@ -1,60 +0,0 @@
-export type CronSessionPolicy = "stateless" | "shared-session";
-
-export type JobSchedule =
-  | { kind: "at"; at: string }
-  | { kind: "every"; everyMs: number }
-  | { kind: "cron"; expr: string; tz?: string | undefined };
-
-export interface JobDelivery {
-  connectorId: string;
-  routeId: string;
-  channelId: string;
-  threadId?: string | undefined;
-}
-
-export interface ScheduledJobState {
-  nextRunAtMs?: number | undefined;
-  runningAtMs?: number | undefined;
-  lastRunAtMs?: number | undefined;
-  lastStatus?: "ok" | "error" | "skipped" | undefined;
-  lastError?: string | undefined;
-  consecutiveErrors?: number | undefined;
-}
-
-export interface ScheduledJob {
-  id: string;
-  name: string;
-  enabled: boolean;
-  schedule: JobSchedule;
-  sessionPolicy?: CronSessionPolicy | undefined;
-  prompt: string;
-  delivery: JobDelivery;
-  createdAtMs: number;
-  updatedAtMs: number;
-  state: ScheduledJobState;
-}
-
-export interface CronConfig {
-  enabled: boolean;
-  storeFile: string;
-  runLogFile: string;
-  pollIntervalMs: number;
-  maxConcurrentRuns: number;
-  runMissedOnStartup: boolean;
-  jobTimeoutMs: number;
-}
-
-export interface CronRunLogRecord {
-  runId: string;
-  jobId: string;
-  jobName: string;
-  startedAtMs: number;
-  endedAtMs: number;
-  status: "ok" | "error" | "timeout";
-  error?: string;
-}
-
-export interface CronJobsSnapshot {
-  version: 1;
-  jobs: ScheduledJob[];
-}

package/src/extension/loader.ts

@@ -1,145 +0,0 @@
-import { access } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import type {
-  ExtensionContributionManifest,
-  ExtensionContributionModule,
-  ExtensionManifest,
-  ExtensionPackageConfig,
-  GatewayLogger,
-} from "../core/types.js";
-import { readExtensionManifest } from "./manifest.js";
-
-export interface LoadedExtensionContribution {
-  manifest: ExtensionContributionManifest;
-  module: ExtensionContributionModule;
-}
-
-export interface LoadedExtensionPackage {
-  packageName: string;
-  manifest: ExtensionManifest;
-  contributions: LoadedExtensionContribution[];
-}
-
-interface ExtensionLoaderOptions {
-  extensionsDir: string;
-}
-
-function isJavaScriptEntry(entry: string): boolean {
-  return entry.endsWith(".js") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
-}
-
-function assertWithinRoot(pathToCheck: string, rootDir: string): void {
-  const normalizedRoot = resolve(rootDir);
-  const normalizedPath = resolve(pathToCheck);
-  if (normalizedPath === normalizedRoot) {
-    return;
-  }
-
-  const rootPrefix = normalizedRoot.endsWith("/") || normalizedRoot.endsWith("\\")
-    ? normalizedRoot
-    : `${normalizedRoot}${process.platform === "win32" ? "\\" : "/"}`;
-  if (!normalizedPath.startsWith(rootPrefix)) {
-    throw new Error(`Path '${normalizedPath}' escapes package root '${normalizedRoot}'`);
-  }
-}
-
-function pickContributionModule(loadedModule: Record<string, unknown>): unknown {
-  if ("default" in loadedModule) {
-    return loadedModule.default;
-  }
-  if ("contribution" in loadedModule) {
-    return loadedModule.contribution;
-  }
-  return undefined;
-}
-
-export class ExtensionLoader {
-  private readonly extensionRequire: NodeJS.Require;
-
-  constructor(
-    private readonly logger: GatewayLogger,
-    private readonly options: ExtensionLoaderOptions,
-  ) {
-    this.extensionRequire = createRequire(join(this.options.extensionsDir, "package.json"));
-  }
-
-  async loadAllowList(allowList: ExtensionPackageConfig[]): Promise<LoadedExtensionPackage[]> {
-    const loaded: LoadedExtensionPackage[] = [];
-
-    for (const packageConfig of allowList) {
-      if (packageConfig.enabled === false) {
-        this.logger.info({ package: packageConfig.package }, "Skipping disabled extension package");
-        continue;
-      }
-
-      loaded.push(await this.loadExternalPackage(packageConfig.package));
-    }
-
-    return loaded;
-  }
-
-  private async loadExternalPackage(packageName: string): Promise<LoadedExtensionPackage> {
-    let packageJsonPath: string;
-    try {
-      packageJsonPath = this.extensionRequire.resolve(`${packageName}/package.json`);
-    } catch (error) {
-      throw new Error(
-        `Extension package '${packageName}' is not installed in '${this.options.extensionsDir}'. ` +
-        `Install it with: dobby extension install ${packageName}. ` +
-        `Resolver error: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-
-    const packageRoot = dirname(packageJsonPath);
-    const manifestPath = resolve(join(packageRoot, "dobby.manifest.json"));
-    const manifest = await readExtensionManifest(manifestPath);
-
-    const contributions: LoadedExtensionContribution[] = [];
-    for (const contributionManifest of manifest.contributions) {
-      if (!isJavaScriptEntry(contributionManifest.entry)) {
-        throw new Error(
-          `Contribution '${contributionManifest.id}' in package '${packageName}' must use a built JavaScript entry, got '${contributionManifest.entry}'`,
-        );
-      }
-
-      const entryPath = resolve(packageRoot, contributionManifest.entry);
-      assertWithinRoot(entryPath, packageRoot);
-      try {
-        await access(entryPath);
-      } catch {
-        throw new Error(
-          `Contribution '${contributionManifest.id}' in package '${packageName}' points to missing entry '${contributionManifest.entry}'`,
-        );
-      }
-
-      const loadedModule = (await import(pathToFileURL(entryPath).href)) as Record<string, unknown>;
-      const contributionModule = pickContributionModule(loadedModule);
-
-      if (!contributionModule || typeof contributionModule !== "object") {
-        throw new Error(
-          `Extension contribution '${contributionManifest.id}' from package '${packageName}' does not export a valid module`,
-        );
-      }
-
-      const kind = (contributionModule as { kind?: string }).kind;
-      if (kind !== contributionManifest.kind) {
-        throw new Error(
-          `Contribution kind mismatch for '${contributionManifest.id}' in package '${packageName}': manifest=${contributionManifest.kind}, module=${kind ?? "unknown"}`,
-        );
-      }
-
-      contributions.push({
-        manifest: contributionManifest,
-        module: contributionModule as ExtensionContributionModule,
-      });
-    }
-
-    return {
-      packageName,
-      manifest,
-      contributions,
-    };
-  }
-}