@hachej/boring-automation 0.1.71

package/README.md

@@ -0,0 +1,5 @@
+# @hachej/boring-automation
+
+Trusted Boring workspace plugin for scheduled prompt automations.
+
+Slice 1 provides the package shell, single-workspace file-backed automation store, automation/prompt CRUD routes, and read-only run-history routes. Execution and scheduling are intentionally gated on the issue #590 seam-confirmation slice.

package/dist/front/index.d.ts

@@ -0,0 +1,7 @@
+import { BoringFrontFactoryWithId } from '@hachej/boring-workspace/plugin';
+export { Automation, AutomationCreate, AutomationCreateInput, AutomationCreateSchema, AutomationPatch, AutomationPatchInput, AutomationPatchSchema, AutomationRun, AutomationRunCreate, AutomationRunCreateInput, AutomationRunCreateSchema, AutomationRunPatch, AutomationRunPatchInput, AutomationRunPatchSchema, AutomationRunStatus, AutomationRunStatusSchema, AutomationRunTrigger, AutomationRunTriggerSchema, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, BoringAutomationErrorCode, IdParamsSchema, PromptUpdateSchema } from '../shared/index.js';
+import 'zod';
+
+declare const boringAutomationPlugin: BoringFrontFactoryWithId;
+
+export { boringAutomationPlugin, boringAutomationPlugin as default };

package/dist/front/index.js

@@ -0,0 +1,122 @@
+"use client";
+
+// src/front/index.tsx
+import { definePlugin } from "@hachej/boring-workspace/plugin";
+import { CalendarClock } from "lucide-react";
+
+// src/shared/constants.ts
+var BORING_AUTOMATION_PLUGIN_ID = "boring-automation";
+var BORING_AUTOMATION_PLUGIN_LABEL = "Automations";
+var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
+
+// src/shared/error-codes.ts
+var BORING_AUTOMATION_ERROR_CODES = {
+  INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+};
+
+// src/shared/schema.ts
+import { z } from "zod";
+var nonEmptyString = z.string().trim().min(1);
+var isoString = z.string().datetime({ offset: true });
+var nonNegativeInteger = z.number().int().nonnegative();
+var AutomationRunStatusSchema = z.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
+var AutomationRunTriggerSchema = z.enum(["manual", "scheduled"]);
+var AutomationCreateSchema = z.object({
+  title: nonEmptyString,
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString,
+  timezone: nonEmptyString,
+  model: nonEmptyString,
+  prompt: z.string().optional()
+}).strict();
+var AutomationPatchSchema = z.object({
+  title: nonEmptyString.optional(),
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString.optional(),
+  timezone: nonEmptyString.optional(),
+  model: nonEmptyString.optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var PromptUpdateSchema = z.object({
+  prompt: z.string()
+}).strict();
+var AutomationRunCreateSchema = z.object({
+  automationId: nonEmptyString,
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  trigger: AutomationRunTriggerSchema,
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  promptSnapshot: z.string(),
+  modelSnapshot: nonEmptyString,
+  error: z.string().nullable().optional()
+}).strict();
+var AutomationRunPatchSchema = z.object({
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  error: z.string().nullable().optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var IdParamsSchema = z.object({ id: nonEmptyString });
+
+// src/front/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function AutomationPanel() {
+  return /* @__PURE__ */ jsxs("div", { className: "flex h-full min-h-0 flex-col bg-background p-4 text-sm text-foreground", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 font-medium", children: [
+      /* @__PURE__ */ jsx(CalendarClock, { className: "h-4 w-4 text-muted-foreground" }),
+      BORING_AUTOMATION_PLUGIN_LABEL
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "mt-2 max-w-prose text-sm text-muted-foreground", children: "Automation UI is implemented in the next slice. Slice 1 provides the trusted plugin shell, file-backed store, and CRUD routes." })
+  ] });
+}
+var boringAutomationPlugin = definePlugin({
+  id: BORING_AUTOMATION_PLUGIN_ID,
+  label: BORING_AUTOMATION_PLUGIN_LABEL,
+  panels: [
+    {
+      id: `${BORING_AUTOMATION_PLUGIN_ID}.panel`,
+      label: BORING_AUTOMATION_PLUGIN_LABEL,
+      icon: CalendarClock,
+      component: AutomationPanel,
+      placement: "center",
+      source: "builtin"
+    }
+  ],
+  commands: [
+    {
+      id: `${BORING_AUTOMATION_PLUGIN_ID}.open`,
+      title: "Open Automations",
+      panelId: `${BORING_AUTOMATION_PLUGIN_ID}.panel`
+    }
+  ]
+});
+var front_default = boringAutomationPlugin;
+export {
+  AutomationCreateSchema,
+  AutomationPatchSchema,
+  AutomationRunCreateSchema,
+  AutomationRunPatchSchema,
+  AutomationRunStatusSchema,
+  AutomationRunTriggerSchema,
+  BORING_AUTOMATION_ERROR_CODES,
+  BORING_AUTOMATION_PLUGIN_ID,
+  BORING_AUTOMATION_PLUGIN_LABEL,
+  BORING_AUTOMATION_ROUTE_PREFIX,
+  IdParamsSchema,
+  PromptUpdateSchema,
+  boringAutomationPlugin,
+  front_default as default
+};

package/dist/server/index.d.ts

@@ -0,0 +1,71 @@
+import { WorkspaceServerPlugin } from '@hachej/boring-workspace/server';
+import { Automation, AutomationCreate, AutomationPatch, AutomationRunCreate, AutomationRun, AutomationRunPatch, BoringAutomationErrorCode } from '../shared/index.js';
+export { AutomationCreateInput, AutomationCreateSchema, AutomationPatchInput, AutomationPatchSchema, AutomationRunCreateInput, AutomationRunCreateSchema, AutomationRunPatchInput, AutomationRunPatchSchema, AutomationRunStatus, AutomationRunStatusSchema, AutomationRunTrigger, AutomationRunTriggerSchema, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, IdParamsSchema, PromptUpdateSchema } from '../shared/index.js';
+import { FastifyInstance } from 'fastify';
+import 'zod';
+
+/** Plugin-local dependency injection seam for the single-workspace automation store. */
+interface AutomationStore {
+    listAutomations(): Promise<Automation[]>;
+    getAutomation(id: string): Promise<Automation | null>;
+    createAutomation(input: AutomationCreate): Promise<Automation>;
+    updateAutomation(id: string, patch: AutomationPatch): Promise<Automation>;
+    deleteAutomation(id: string): Promise<void>;
+    getPrompt(automationId: string): Promise<string>;
+    updatePrompt(automationId: string, body: string): Promise<void>;
+    createRun(input: AutomationRunCreate): Promise<AutomationRun>;
+    updateRun(runId: string, patch: AutomationRunPatch): Promise<AutomationRun>;
+    listRuns(automationId: string): Promise<AutomationRun[]>;
+    findRunningRun(automationId: string): Promise<AutomationRun | null>;
+}
+declare class AutomationStoreError extends Error {
+    readonly code: BoringAutomationErrorCode;
+    constructor(code: BoringAutomationErrorCode, message: string);
+}
+declare function automationNotFound(id: string): AutomationStoreError;
+declare function runNotFound(id: string): AutomationStoreError;
+
+type AtomicWriter = (path: string, content: string) => Promise<void>;
+interface FileAutomationStoreOptions {
+    writer?: AtomicWriter;
+}
+declare class FileAutomationStore implements AutomationStore {
+    private readonly rootDir;
+    private state;
+    private loadInFlight;
+    private writeChain;
+    private readonly writer;
+    constructor(rootDir: string, options?: FileAutomationStoreOptions);
+    listAutomations(): Promise<Automation[]>;
+    getAutomation(id: string): Promise<Automation | null>;
+    createAutomation(input: AutomationCreate): Promise<Automation>;
+    updateAutomation(id: string, patch: AutomationPatch): Promise<Automation>;
+    deleteAutomation(id: string): Promise<void>;
+    getPrompt(automationId: string): Promise<string>;
+    updatePrompt(automationId: string, body: string): Promise<void>;
+    createRun(input: AutomationRunCreate): Promise<AutomationRun>;
+    updateRun(runId: string, patch: AutomationRunPatch): Promise<AutomationRun>;
+    listRuns(automationId: string): Promise<AutomationRun[]>;
+    findRunningRun(automationId: string): Promise<AutomationRun | null>;
+    private statePath;
+    private promptPath;
+    private writePromptFile;
+    private mutate;
+    private load;
+}
+
+interface AutomationRoutesOptions {
+    store: AutomationStore;
+}
+declare function automationRoutes(app: FastifyInstance, opts: AutomationRoutesOptions): Promise<void>;
+
+interface BoringAutomationServerPluginOptions {
+    workspaceRoot?: string;
+    store?: AutomationStore;
+}
+declare function createBoringAutomationServerPlugin(options?: BoringAutomationServerPluginOptions): WorkspaceServerPlugin;
+declare function defaultBoringAutomationServerPlugin(options?: BoringAutomationServerPluginOptions, ctx?: {
+    workspaceRoot?: string;
+}): WorkspaceServerPlugin;
+
+export { Automation, AutomationCreate, AutomationPatch, type AutomationRoutesOptions, AutomationRun, AutomationRunCreate, AutomationRunPatch, type AutomationStore, AutomationStoreError, BoringAutomationErrorCode, type BoringAutomationServerPluginOptions, FileAutomationStore, type FileAutomationStoreOptions, automationNotFound, automationRoutes, createBoringAutomationServerPlugin, defaultBoringAutomationServerPlugin as default, runNotFound };

package/dist/server/index.js

@@ -0,0 +1,451 @@
+// src/server/index.ts
+import { join as join2 } from "path";
+import { defineServerPlugin } from "@hachej/boring-workspace/server";
+
+// src/shared/constants.ts
+var BORING_AUTOMATION_PLUGIN_ID = "boring-automation";
+var BORING_AUTOMATION_PLUGIN_LABEL = "Automations";
+var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
+
+// src/shared/error-codes.ts
+var BORING_AUTOMATION_ERROR_CODES = {
+  INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+};
+
+// src/shared/schema.ts
+import { z } from "zod";
+var nonEmptyString = z.string().trim().min(1);
+var isoString = z.string().datetime({ offset: true });
+var nonNegativeInteger = z.number().int().nonnegative();
+var AutomationRunStatusSchema = z.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
+var AutomationRunTriggerSchema = z.enum(["manual", "scheduled"]);
+var AutomationCreateSchema = z.object({
+  title: nonEmptyString,
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString,
+  timezone: nonEmptyString,
+  model: nonEmptyString,
+  prompt: z.string().optional()
+}).strict();
+var AutomationPatchSchema = z.object({
+  title: nonEmptyString.optional(),
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString.optional(),
+  timezone: nonEmptyString.optional(),
+  model: nonEmptyString.optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var PromptUpdateSchema = z.object({
+  prompt: z.string()
+}).strict();
+var AutomationRunCreateSchema = z.object({
+  automationId: nonEmptyString,
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  trigger: AutomationRunTriggerSchema,
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  promptSnapshot: z.string(),
+  modelSnapshot: nonEmptyString,
+  error: z.string().nullable().optional()
+}).strict();
+var AutomationRunPatchSchema = z.object({
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  error: z.string().nullable().optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var IdParamsSchema = z.object({ id: nonEmptyString });
+
+// src/server/fileStore.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+
+// src/server/store.ts
+var AutomationStoreError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+function automationNotFound(id) {
+  return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.AUTOMATION_NOT_FOUND, `automation ${id} not found`);
+}
+function runNotFound(id) {
+  return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_NOT_FOUND, `automation run ${id} not found`);
+}
+
+// src/server/fileStore.ts
+var EMPTY_STATE = {
+  automations: {},
+  runs: {}
+};
+var SAFE_PROMPT_ID = /^[a-zA-Z0-9_-]+$/;
+var DEFAULT_PROMPT = "";
+var FileAutomationStore = class {
+  constructor(rootDir, options = {}) {
+    this.rootDir = rootDir;
+    this.writer = options.writer ?? writeAtomic;
+  }
+  rootDir;
+  state = null;
+  loadInFlight = null;
+  writeChain = Promise.resolve();
+  writer;
+  async listAutomations() {
+    const state = await this.load();
+    return Object.values(state.automations).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map(clone);
+  }
+  async getAutomation(id) {
+    const state = await this.load();
+    const automation = state.automations[id];
+    return automation ? clone(automation) : null;
+  }
+  async createAutomation(input) {
+    const now = nowIso();
+    const id = randomUUID();
+    const automation = {
+      id,
+      title: input.title,
+      enabled: input.enabled ?? true,
+      cron: input.cron,
+      timezone: input.timezone,
+      model: input.model,
+      promptRef: promptRefForId(id),
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.writePromptFile(automation.id, input.prompt ?? DEFAULT_PROMPT);
+    await this.mutate((state) => {
+      state.automations[automation.id] = clone(automation);
+    });
+    return clone(automation);
+  }
+  async updateAutomation(id, patch) {
+    let updated;
+    await this.mutate((state) => {
+      const automation = state.automations[id];
+      if (!automation) throw automationNotFound(id);
+      updated = {
+        ...automation,
+        ...patch,
+        id: automation.id,
+        promptRef: automation.promptRef,
+        createdAt: automation.createdAt,
+        updatedAt: nowIso()
+      };
+      state.automations[id] = updated;
+    });
+    return clone(requireValue(updated));
+  }
+  async deleteAutomation(id) {
+    await this.mutate((state) => {
+      if (!state.automations[id]) throw automationNotFound(id);
+      delete state.automations[id];
+    });
+  }
+  async getPrompt(automationId) {
+    const automation = await this.getAutomation(automationId);
+    if (!automation) throw automationNotFound(automationId);
+    try {
+      return await readFile(this.promptPath(automationId), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return DEFAULT_PROMPT;
+      throw error;
+    }
+  }
+  async updatePrompt(automationId, body) {
+    const automation = await this.getAutomation(automationId);
+    if (!automation) throw automationNotFound(automationId);
+    await this.writePromptFile(automationId, body);
+    await this.mutate((state) => {
+      const current = state.automations[automationId];
+      if (!current) throw automationNotFound(automationId);
+      current.updatedAt = nowIso();
+    });
+  }
+  async createRun(input) {
+    const now = nowIso();
+    let run;
+    await this.mutate((state) => {
+      if (!state.automations[input.automationId]) throw automationNotFound(input.automationId);
+      run = {
+        id: randomUUID(),
+        automationId: input.automationId,
+        sessionId: input.sessionId ?? null,
+        status: input.status ?? "queued",
+        trigger: input.trigger,
+        scheduledFor: input.scheduledFor ?? null,
+        startedAt: input.startedAt ?? null,
+        completedAt: input.completedAt ?? null,
+        durationMs: input.durationMs ?? null,
+        inputTokens: input.inputTokens ?? null,
+        outputTokens: input.outputTokens ?? null,
+        totalTokens: input.totalTokens ?? null,
+        promptSnapshot: input.promptSnapshot,
+        modelSnapshot: input.modelSnapshot,
+        error: input.error ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      state.runs[run.id] = clone(run);
+    });
+    return clone(requireValue(run));
+  }
+  async updateRun(runId, patch) {
+    let updated;
+    await this.mutate((state) => {
+      const run = state.runs[runId];
+      if (!run) throw runNotFound(runId);
+      updated = applyRunPatch(run, patch);
+      state.runs[runId] = updated;
+    });
+    return clone(requireValue(updated));
+  }
+  async listRuns(automationId) {
+    const automation = await this.getAutomation(automationId);
+    if (!automation) throw automationNotFound(automationId);
+    const state = await this.load();
+    return Object.values(state.runs).filter((run) => run.automationId === automationId).sort((a, b) => runSortTimestamp(b).localeCompare(runSortTimestamp(a))).map(clone);
+  }
+  async findRunningRun(automationId) {
+    const runs = await this.listRuns(automationId);
+    return runs.find((run) => run.status === "running") ?? null;
+  }
+  statePath() {
+    return join(this.rootDir, "store.json");
+  }
+  promptPath(automationId) {
+    if (!SAFE_PROMPT_ID.test(automationId)) throw automationNotFound(automationId);
+    return join(this.rootDir, "prompts", `${automationId}.md`);
+  }
+  async writePromptFile(automationId, body) {
+    await this.writer(this.promptPath(automationId), body);
+  }
+  async mutate(fn) {
+    const run = this.writeChain.then(async () => {
+      const state = clone(await this.load());
+      await fn(state);
+      await this.writer(this.statePath(), `${JSON.stringify(state, null, 2)}
+`);
+      this.state = state;
+    });
+    this.writeChain = run.catch(() => void 0);
+    return run;
+  }
+  async load() {
+    if (this.state) return this.state;
+    if (!this.loadInFlight) {
+      this.loadInFlight = (async () => {
+        try {
+          const raw = await readFile(this.statePath(), "utf8");
+          const parsed = JSON.parse(raw);
+          this.state = {
+            automations: parsed.automations && typeof parsed.automations === "object" ? parsed.automations : {},
+            runs: parsed.runs && typeof parsed.runs === "object" ? parsed.runs : {}
+          };
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+          this.state = clone(EMPTY_STATE);
+        }
+        return this.state;
+      })().finally(() => {
+        this.loadInFlight = null;
+      });
+    }
+    return this.loadInFlight;
+  }
+};
+function promptRefForId(id) {
+  return `prompts/${id}.md`;
+}
+function applyRunPatch(run, patch) {
+  const next = { ...run, updatedAt: nowIso() };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== void 0) next[key] = value;
+  }
+  return next;
+}
+function runSortTimestamp(run) {
+  return run.startedAt ?? run.scheduledFor ?? run.createdAt;
+}
+async function writeAtomic(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = join(dirname(path), `.${randomUUID()}.tmp`);
+  await writeFile(tmp, content, "utf8");
+  await rename(tmp, path);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function requireValue(value) {
+  if (value === void 0) throw new Error("expected automation store mutation to produce a value");
+  return value;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/server/routes.ts
+import { ZodError } from "zod";
+async function automationRoutes(app, opts) {
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (_request, reply) => {
+    try {
+      return { ok: true, automations: await opts.store.listAutomations() };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.post(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (request, reply) => {
+    try {
+      const automation = await opts.store.createAutomation(parseBody(AutomationCreateSchema, request.body));
+      return reply.status(201).send({ ok: true, automation });
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      const automation = await opts.store.getAutomation(id);
+      if (!automation) throw automationNotFound(id);
+      return { ok: true, automation };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.patch(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      const automation = await opts.store.updateAutomation(id, parseBody(AutomationPatchSchema, request.body));
+      return { ok: true, automation };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.delete(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      await opts.store.deleteAutomation(id);
+      return reply.status(204).send();
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/prompt`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      return { ok: true, prompt: await opts.store.getPrompt(id) };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.put(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/prompt`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      const { prompt } = parseBody(PromptUpdateSchema, request.body);
+      await opts.store.updatePrompt(id, prompt);
+      return { ok: true };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/runs`, async (request, reply) => {
+    try {
+      const { id } = parseParams(IdParamsSchema, request.params);
+      return { ok: true, runs: await opts.store.listRuns(id) };
+    } catch (cause) {
+      return sendError(reply, cause);
+    }
+  });
+}
+function parseBody(schema, body) {
+  return parse(schema, body);
+}
+function parseParams(schema, params) {
+  return parse(schema, params);
+}
+function parse(schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) throw parsed.error;
+  return parsed.data;
+}
+function sendError(reply, cause) {
+  if (cause instanceof ZodError) {
+    return reply.status(400).send({
+      ok: false,
+      code: BORING_AUTOMATION_ERROR_CODES.INVALID_BODY,
+      error: cause.issues[0]?.message ?? "invalid request"
+    });
+  }
+  if (cause instanceof AutomationStoreError) {
+    return reply.status(httpStatusForStoreError(cause)).send({ ok: false, code: cause.code, error: cause.message });
+  }
+  throw cause;
+}
+function httpStatusForStoreError(error) {
+  switch (error.code) {
+    case BORING_AUTOMATION_ERROR_CODES.INVALID_BODY:
+      return 400;
+    case BORING_AUTOMATION_ERROR_CODES.AUTOMATION_NOT_FOUND:
+    case BORING_AUTOMATION_ERROR_CODES.RUN_NOT_FOUND:
+      return 404;
+  }
+}
+
+// src/server/index.ts
+function createBoringAutomationServerPlugin(options = {}) {
+  const store = options.store ?? createDefaultStore(options.workspaceRoot);
+  return defineServerPlugin({
+    id: BORING_AUTOMATION_PLUGIN_ID,
+    label: BORING_AUTOMATION_PLUGIN_LABEL,
+    routes: async (app) => {
+      await automationRoutes(app, { store });
+    }
+  });
+}
+function createDefaultStore(workspaceRoot) {
+  if (!workspaceRoot) throw new Error("createBoringAutomationServerPlugin requires workspaceRoot when store is not provided");
+  return new FileAutomationStore(join2(workspaceRoot, ".pi", "automation"));
+}
+function defaultBoringAutomationServerPlugin(options, ctx) {
+  return createBoringAutomationServerPlugin({
+    ...options,
+    workspaceRoot: options?.workspaceRoot ?? ctx?.workspaceRoot
+  });
+}
+export {
+  AutomationCreateSchema,
+  AutomationPatchSchema,
+  AutomationRunCreateSchema,
+  AutomationRunPatchSchema,
+  AutomationRunStatusSchema,
+  AutomationRunTriggerSchema,
+  AutomationStoreError,
+  BORING_AUTOMATION_ERROR_CODES,
+  BORING_AUTOMATION_PLUGIN_ID,
+  BORING_AUTOMATION_PLUGIN_LABEL,
+  BORING_AUTOMATION_ROUTE_PREFIX,
+  FileAutomationStore,
+  IdParamsSchema,
+  PromptUpdateSchema,
+  automationNotFound,
+  automationRoutes,
+  createBoringAutomationServerPlugin,
+  defaultBoringAutomationServerPlugin as default,
+  runNotFound
+};

package/dist/shared/index.d.ts

@@ -0,0 +1,266 @@
+import { z } from 'zod';
+
+declare const BORING_AUTOMATION_PLUGIN_ID = "boring-automation";
+declare const BORING_AUTOMATION_PLUGIN_LABEL = "Automations";
+declare const BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
+
+declare const BORING_AUTOMATION_ERROR_CODES: {
+    readonly INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY";
+    readonly AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND";
+    readonly RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND";
+};
+type BoringAutomationErrorCode = typeof BORING_AUTOMATION_ERROR_CODES[keyof typeof BORING_AUTOMATION_ERROR_CODES];
+
+declare const AutomationRunStatusSchema: z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>;
+declare const AutomationRunTriggerSchema: z.ZodEnum<["manual", "scheduled"]>;
+declare const AutomationCreateSchema: z.ZodObject<{
+    title: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    cron: z.ZodString;
+    timezone: z.ZodString;
+    model: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    cron: string;
+    timezone: string;
+    model: string;
+    enabled?: boolean | undefined;
+    prompt?: string | undefined;
+}, {
+    title: string;
+    cron: string;
+    timezone: string;
+    model: string;
+    enabled?: boolean | undefined;
+    prompt?: string | undefined;
+}>;
+declare const AutomationPatchSchema: z.ZodEffects<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    cron: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    title?: string | undefined;
+    enabled?: boolean | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    model?: string | undefined;
+}, {
+    title?: string | undefined;
+    enabled?: boolean | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    model?: string | undefined;
+}>, {
+    title?: string | undefined;
+    enabled?: boolean | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    model?: string | undefined;
+}, {
+    title?: string | undefined;
+    enabled?: boolean | undefined;
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    model?: string | undefined;
+}>;
+declare const PromptUpdateSchema: z.ZodObject<{
+    prompt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    prompt: string;
+}, {
+    prompt: string;
+}>;
+declare const AutomationRunCreateSchema: z.ZodObject<{
+    automationId: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>>;
+    trigger: z.ZodEnum<["manual", "scheduled"]>;
+    scheduledFor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    totalTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    promptSnapshot: z.ZodString;
+    modelSnapshot: z.ZodString;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    automationId: string;
+    trigger: "manual" | "scheduled";
+    promptSnapshot: string;
+    modelSnapshot: string;
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}, {
+    automationId: string;
+    trigger: "manual" | "scheduled";
+    promptSnapshot: string;
+    modelSnapshot: string;
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}>;
+declare const AutomationRunPatchSchema: z.ZodEffects<z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<["queued", "running", "succeeded", "failed", "cancelled"]>>;
+    scheduledFor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    totalTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}, {
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}>, {
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}, {
+    error?: string | null | undefined;
+    status?: "queued" | "running" | "succeeded" | "failed" | "cancelled" | undefined;
+    sessionId?: string | null | undefined;
+    scheduledFor?: string | null | undefined;
+    startedAt?: string | null | undefined;
+    completedAt?: string | null | undefined;
+    durationMs?: number | null | undefined;
+    inputTokens?: number | null | undefined;
+    outputTokens?: number | null | undefined;
+    totalTokens?: number | null | undefined;
+}>;
+declare const IdParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+type AutomationCreateInput = z.infer<typeof AutomationCreateSchema>;
+type AutomationPatchInput = z.infer<typeof AutomationPatchSchema>;
+type AutomationRunCreateInput = z.infer<typeof AutomationRunCreateSchema>;
+type AutomationRunPatchInput = z.infer<typeof AutomationRunPatchSchema>;
+
+type AutomationRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+type AutomationRunTrigger = "manual" | "scheduled";
+interface Automation {
+    id: string;
+    title: string;
+    enabled: boolean;
+    cron: string;
+    timezone: string;
+    model: string;
+    promptRef: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AutomationCreate {
+    title: string;
+    enabled?: boolean;
+    cron: string;
+    timezone: string;
+    model: string;
+    prompt?: string;
+}
+interface AutomationPatch {
+    title?: string;
+    enabled?: boolean;
+    cron?: string;
+    timezone?: string;
+    model?: string;
+}
+interface AutomationRun {
+    id: string;
+    automationId: string;
+    sessionId: string | null;
+    status: AutomationRunStatus;
+    trigger: AutomationRunTrigger;
+    scheduledFor: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    durationMs: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+    promptSnapshot: string;
+    modelSnapshot: string;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AutomationRunCreate {
+    automationId: string;
+    sessionId?: string | null;
+    status?: AutomationRunStatus;
+    trigger: AutomationRunTrigger;
+    scheduledFor?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    durationMs?: number | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    totalTokens?: number | null;
+    promptSnapshot: string;
+    modelSnapshot: string;
+    error?: string | null;
+}
+interface AutomationRunPatch {
+    sessionId?: string | null;
+    status?: AutomationRunStatus;
+    scheduledFor?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    durationMs?: number | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    totalTokens?: number | null;
+    error?: string | null;
+}
+
+export { type Automation, type AutomationCreate, type AutomationCreateInput, AutomationCreateSchema, type AutomationPatch, type AutomationPatchInput, AutomationPatchSchema, type AutomationRun, type AutomationRunCreate, type AutomationRunCreateInput, AutomationRunCreateSchema, type AutomationRunPatch, type AutomationRunPatchInput, AutomationRunPatchSchema, type AutomationRunStatus, AutomationRunStatusSchema, type AutomationRunTrigger, AutomationRunTriggerSchema, BORING_AUTOMATION_ERROR_CODES, BORING_AUTOMATION_PLUGIN_ID, BORING_AUTOMATION_PLUGIN_LABEL, BORING_AUTOMATION_ROUTE_PREFIX, type BoringAutomationErrorCode, IdParamsSchema, PromptUpdateSchema };

package/dist/shared/index.js

@@ -0,0 +1,80 @@
+// src/shared/constants.ts
+var BORING_AUTOMATION_PLUGIN_ID = "boring-automation";
+var BORING_AUTOMATION_PLUGIN_LABEL = "Automations";
+var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
+
+// src/shared/error-codes.ts
+var BORING_AUTOMATION_ERROR_CODES = {
+  INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+};
+
+// src/shared/schema.ts
+import { z } from "zod";
+var nonEmptyString = z.string().trim().min(1);
+var isoString = z.string().datetime({ offset: true });
+var nonNegativeInteger = z.number().int().nonnegative();
+var AutomationRunStatusSchema = z.enum(["queued", "running", "succeeded", "failed", "cancelled"]);
+var AutomationRunTriggerSchema = z.enum(["manual", "scheduled"]);
+var AutomationCreateSchema = z.object({
+  title: nonEmptyString,
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString,
+  timezone: nonEmptyString,
+  model: nonEmptyString,
+  prompt: z.string().optional()
+}).strict();
+var AutomationPatchSchema = z.object({
+  title: nonEmptyString.optional(),
+  enabled: z.boolean().optional(),
+  cron: nonEmptyString.optional(),
+  timezone: nonEmptyString.optional(),
+  model: nonEmptyString.optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var PromptUpdateSchema = z.object({
+  prompt: z.string()
+}).strict();
+var AutomationRunCreateSchema = z.object({
+  automationId: nonEmptyString,
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  trigger: AutomationRunTriggerSchema,
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  promptSnapshot: z.string(),
+  modelSnapshot: nonEmptyString,
+  error: z.string().nullable().optional()
+}).strict();
+var AutomationRunPatchSchema = z.object({
+  sessionId: nonEmptyString.nullable().optional(),
+  status: AutomationRunStatusSchema.optional(),
+  scheduledFor: isoString.nullable().optional(),
+  startedAt: isoString.nullable().optional(),
+  completedAt: isoString.nullable().optional(),
+  durationMs: nonNegativeInteger.nullable().optional(),
+  inputTokens: nonNegativeInteger.nullable().optional(),
+  outputTokens: nonNegativeInteger.nullable().optional(),
+  totalTokens: nonNegativeInteger.nullable().optional(),
+  error: z.string().nullable().optional()
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+var IdParamsSchema = z.object({ id: nonEmptyString });
+export {
+  AutomationCreateSchema,
+  AutomationPatchSchema,
+  AutomationRunCreateSchema,
+  AutomationRunPatchSchema,
+  AutomationRunStatusSchema,
+  AutomationRunTriggerSchema,
+  BORING_AUTOMATION_ERROR_CODES,
+  BORING_AUTOMATION_PLUGIN_ID,
+  BORING_AUTOMATION_PLUGIN_LABEL,
+  BORING_AUTOMATION_ROUTE_PREFIX,
+  IdParamsSchema,
+  PromptUpdateSchema
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@hachej/boring-automation",
+  "version": "0.1.71",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "description": "Scheduled prompt automation plugin for Boring workspace.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hachej/boring-ui"
+  },
+  "homepage": "https://github.com/hachej/boring-ui",
+  "boring": {
+    "id": "boring-automation",
+    "label": "Automations",
+    "front": "dist/front/index.js",
+    "server": "dist/server/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./front": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --no-file-parallelism",
+    "lint": "pnpm run typecheck",
+    "clean": "rm -rf dist .tsbuildinfo"
+  },
+  "peerDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "fastify": "^5.9.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "dependencies": {
+    "@hachej/boring-ui-kit": "workspace:*",
+    "lucide-react": "^1.21.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.20.0",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "fastify": "^5.9.0",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "tsup": "^8.4.0",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "peerDependenciesMeta": {
+    "fastify": {
+      "optional": true
+    }
+  }
+}