opencode-jobs 0.1.0 → 0.1.1

package/README.md

@@ -202,3 +202,8 @@ inside opencode.
 ## License
 
 MIT
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the quality and release workflow and
+[ROADMAP.md](ROADMAP.md) for current planning priorities.

package/dist/cli.js

@@ -7,18 +7,7 @@ import { fileURLToPath } from "node:url";
 // src/install.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2, rmdirSync, statSync } from "node:fs";
 import path5 from "node:path";
-
-// src/json.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function stringProperty(record, key) {
-  const value = record[key];
-  return typeof value === "string" ? value : undefined;
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
+import { z as z3 } from "zod";
 
 // src/paths.ts
 import { chmodSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
@@ -80,24 +69,193 @@ function deriveScopeId(workdir) {
 // src/project.ts
 import path4 from "node:path";
 
+// src/job.ts
+import { z } from "zod";
+
+// src/cron.ts
+var DOW_NAMES = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+var MONTH_NAMES = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+function parseBound(raw, field, min, max, names) {
+  const trimmed = raw.trim().toLowerCase();
+  const named = names?.[trimmed];
+  if (named !== undefined)
+    return named;
+  if (!/^\d+$/.test(trimmed))
+    throw new Error(`Invalid ${field} value "${raw}" in cron expression`);
+  const value = Number(trimmed);
+  if (value < min || value > max)
+    throw new Error(`${field} value ${String(value)} out of range ${String(min)}-${String(max)} in cron expression`);
+  return value;
+}
+function parseCronField(raw, field, min, max, names) {
+  if (raw.length === 0)
+    throw new Error(`Empty ${field} field in cron expression`);
+  const values = new Set;
+  for (const part of raw.split(",")) {
+    if (part.length === 0)
+      throw new Error(`Empty ${field} item in cron expression "${raw}"`);
+    const [rangePart = "", stepPart] = part.split("/", 2);
+    if (stepPart !== undefined && (!/^\d+$/.test(stepPart) || Number(stepPart) < 1)) {
+      throw new Error(`Invalid step "/${stepPart}" in ${field} field`);
+    }
+    const step = stepPart === undefined ? 1 : Number(stepPart);
+    let lo;
+    let hi;
+    if (rangePart === "*") {
+      lo = min;
+      hi = max;
+    } else if (rangePart.includes("-")) {
+      const pieces = rangePart.split("-");
+      if (pieces.length !== 2)
+        throw new Error(`Invalid range "${rangePart}" in ${field} field`);
+      const [loPart = "", hiPart = ""] = pieces;
+      lo = parseBound(loPart, field, min, max, names);
+      hi = parseBound(hiPart, field, min, max, names);
+      if (lo > hi)
+        throw new Error(`Descending range "${rangePart}" in ${field} field`);
+    } else {
+      lo = parseBound(rangePart, field, min, max, names);
+      hi = stepPart === undefined ? lo : max;
+    }
+    for (let v = lo;v <= hi; v += step) {
+      values.add(field === "dow" && v === 7 ? 0 : v);
+    }
+  }
+  return [...values].toSorted((a, b) => a - b);
+}
+function parseCron(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5)
+    throw new Error(`Expected 5-field cron expression, got ${String(fields.length)} fields: "${expression}"`);
+  const [minute = "", hour = "", dom = "", month = "", dow = ""] = fields;
+  return {
+    minute: parseCronField(minute, "minute", 0, 59),
+    hour: parseCronField(hour, "hour", 0, 23),
+    dom: parseCronField(dom, "day of month", 1, 31),
+    month: parseCronField(month, "month", 1, 12, MONTH_NAMES),
+    dow: parseCronField(dow, "dow", 0, 7, DOW_NAMES)
+  };
+}
+
+// src/json.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/job.ts
+var SESSION_MODES = [
+  "new",
+  "persist",
+  "compact",
+  "compact+last"
+];
+var nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0, "must be a non-empty string");
+var runSpecSchema = z.strictObject({
+  prompt: nonEmptyStringSchema.optional(),
+  command: nonEmptyStringSchema.optional(),
+  arguments: z.string().optional(),
+  agent: z.string().optional(),
+  model: z.string().optional()
+}).superRefine((run, context) => {
+  if (run.prompt === undefined === (run.command === undefined)) {
+    context.addIssue({
+      code: "custom",
+      message: 'must set exactly one of "prompt" (natural language) or "command" (custom command name)'
+    });
+  }
+  if (run.prompt !== undefined && run.arguments !== undefined) {
+    context.addIssue({
+      code: "custom",
+      path: ["arguments"],
+      message: "only applies to command jobs"
+    });
+  }
+}).transform((run) => {
+  if (run.command !== undefined) {
+    return {
+      command: run.command,
+      ...run.arguments !== undefined && { arguments: run.arguments },
+      ...run.agent !== undefined && { agent: run.agent },
+      ...run.model !== undefined && { model: run.model }
+    };
+  }
+  return {
+    prompt: run.prompt ?? "",
+    ...run.agent !== undefined && { agent: run.agent },
+    ...run.model !== undefined && { model: run.model }
+  };
+});
+var sessionSchema = z.enum(SESSION_MODES, {
+  error: `must be one of ${SESSION_MODES.map((mode) => `"${mode}"`).join(", ")}`
+});
+var guardSchema = z.string().refine((value) => value.trim().length > 0, "must be a non-empty shell command string");
+var timeoutSchema = z.number().int().nonnegative("must be a non-negative integer");
+var cronSchema = z.string().superRefine((schedule, context) => {
+  try {
+    parseCron(schedule);
+  } catch (error) {
+    context.addIssue({ code: "custom", message: errorMessage(error) });
+  }
+});
+var jobFileSchema = z.strictObject({
+  slug: z.string().optional(),
+  name: nonEmptyStringSchema,
+  schedule: cronSchema,
+  run: runSpecSchema,
+  session: sessionSchema.default("new"),
+  guard: guardSchema.optional(),
+  timeoutSeconds: timeoutSchema.optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+
 // src/registry.ts
 import { readFileSync } from "node:fs";
 import path2 from "node:path";
-function isRegistryEntry(value) {
-  if (!isRecord(value))
-    return false;
-  return stringProperty(value, "scopeId") !== undefined && stringProperty(value, "workdir") !== undefined && stringProperty(value, "enabledAt") !== undefined && stringProperty(value, "updatedAt") !== undefined && Array.isArray(value.jobs) && value.jobs.every((job) => typeof job === "string");
-}
+import { z as z2 } from "zod";
+var registryEntrySchema = z2.looseObject({
+  scopeId: z2.string(),
+  workdir: z2.string(),
+  enabledAt: z2.string(),
+  updatedAt: z2.string(),
+  jobs: z2.array(z2.string())
+});
+var registryFileSchema = z2.object({
+  version: z2.literal(1),
+  projects: z2.record(z2.string(), z2.unknown())
+});
 function loadRegistry() {
   try {
     const parsed = JSON.parse(readFileSync(registryPath(), "utf8"));
-    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.projects)) {
+    const result = registryFileSchema.safeParse(parsed);
+    if (!result.success)
       return { version: 1, projects: {} };
-    }
     const projects = {};
-    for (const [key, value] of Object.entries(parsed.projects)) {
-      if (isRegistryEntry(value))
-        projects[key] = value;
+    for (const [key, value] of Object.entries(result.data.projects)) {
+      const entry = registryEntrySchema.safeParse(value);
+      if (entry.success)
+        projects[key] = entry.data;
     }
     return { version: 1, projects };
   } catch {
@@ -169,6 +327,9 @@ function disableProject(workdir) {
 var PACKAGE_NAME = "opencode-jobs";
 var SKILL_NAME = "opencode-jobs";
 var CONFIG_SCHEMA = "https://opencode.ai/config.json";
+var configSchema = z3.looseObject({
+  plugin: z3.array(z3.unknown()).optional()
+});
 var CONFIG_LOCATIONS = [
   "opencode.json",
   "opencode.jsonc",
@@ -186,7 +347,8 @@ function existingConfigPath(projectDirectory) {
 function readConfig(configPath) {
   try {
     const value = JSON.parse(readFileSync2(configPath, "utf8"));
-    return isRecord(value) && !Array.isArray(value) ? value : undefined;
+    const result = configSchema.safeParse(value);
+    return result.success ? result.data : undefined;
   } catch {
     return;
   }
@@ -213,11 +375,7 @@ function installPluginConfig(projectDirectory) {
   const config = readConfig(configPath);
   if (config === undefined)
     return { status: "manual", configPath };
-  const plugins = config.plugin;
-  if (plugins !== undefined && !Array.isArray(plugins)) {
-    return { status: "manual", configPath };
-  }
-  const entries = Array.isArray(plugins) ? plugins : [];
+  const entries = config.plugin ?? [];
   if (entries.some((entry) => isPackageReference(entry))) {
     return { status: "present", configPath };
   }
@@ -260,11 +418,7 @@ function uninstallPluginConfig(projectDirectory) {
   const config = readConfig(configPath);
   if (config === undefined)
     return { status: "manual", configPath };
-  const plugins = config.plugin;
-  if (plugins !== undefined && !Array.isArray(plugins)) {
-    return { status: "manual", configPath };
-  }
-  const entries = Array.isArray(plugins) ? plugins : [];
+  const entries = config.plugin ?? [];
   const remaining = entries.filter((entry) => !isPackageReference(entry));
   if (remaining.length === entries.length) {
     return { status: "absent", configPath };

package/dist/index.js

@@ -227,19 +227,9 @@ function deriveScopeId(workdir) {
 // src/job.ts
 import { existsSync, readFileSync, readdirSync } from "fs";
 import path2 from "path";
+import { z } from "zod";
 
 // src/json.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function stringProperty(record, key) {
-  const value = record[key];
-  return typeof value === "string" ? value : undefined;
-}
-function numberProperty(record, key) {
-  const value = record[key];
-  return typeof value === "number" ? value : undefined;
-}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -251,69 +241,110 @@ var SESSION_MODES = [
   "compact",
   "compact+last"
 ];
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function validateRunSpec(run, context) {
-  if (!isRecord(run))
-    throw new Error(`${context}: "run" must be an object`);
-  const prompt = nonEmptyString(run.prompt);
-  const command = nonEmptyString(run.command);
-  if (prompt !== undefined === (command !== undefined)) {
-    throw new Error(`${context}: "run" must set exactly one of "prompt" (natural language) or "command" (custom command name)`);
+var nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0, "must be a non-empty string");
+var runSpecSchema = z.strictObject({
+  prompt: nonEmptyStringSchema.optional(),
+  command: nonEmptyStringSchema.optional(),
+  arguments: z.string().optional(),
+  agent: z.string().optional(),
+  model: z.string().optional()
+}).superRefine((run, context) => {
+  if (run.prompt === undefined === (run.command === undefined)) {
+    context.addIssue({
+      code: "custom",
+      message: 'must set exactly one of "prompt" (natural language) or "command" (custom command name)'
+    });
   }
-  const commandArguments = stringProperty(run, "arguments");
-  const agent = stringProperty(run, "agent");
-  const model = stringProperty(run, "model");
-  if (command !== undefined) {
+  if (run.prompt !== undefined && run.arguments !== undefined) {
+    context.addIssue({
+      code: "custom",
+      path: ["arguments"],
+      message: "only applies to command jobs"
+    });
+  }
+}).transform((run) => {
+  if (run.command !== undefined) {
     return {
-      command,
-      ...commandArguments !== undefined && { arguments: commandArguments },
-      ...agent !== undefined && { agent },
-      ...model !== undefined && { model }
+      command: run.command,
+      ...run.arguments !== undefined && { arguments: run.arguments },
+      ...run.agent !== undefined && { agent: run.agent },
+      ...run.model !== undefined && { model: run.model }
     };
   }
-  if (commandArguments !== undefined) {
-    throw new Error(`${context}: "run.arguments" only applies to command jobs`);
-  }
   return {
-    prompt: prompt ?? "",
-    ...agent !== undefined && { agent },
-    ...model !== undefined && { model }
+    prompt: run.prompt ?? "",
+    ...run.agent !== undefined && { agent: run.agent },
+    ...run.model !== undefined && { model: run.model }
   };
+});
+var sessionSchema = z.enum(SESSION_MODES, {
+  error: `must be one of ${SESSION_MODES.map((mode) => `"${mode}"`).join(", ")}`
+});
+var guardSchema = z.string().refine((value) => value.trim().length > 0, "must be a non-empty shell command string");
+var timeoutSchema = z.number().int().nonnegative("must be a non-negative integer");
+var cronSchema = z.string().superRefine((schedule, context) => {
+  try {
+    parseCron(schedule);
+  } catch (error) {
+    context.addIssue({ code: "custom", message: errorMessage(error) });
+  }
+});
+var jobFileSchema = z.strictObject({
+  slug: z.string().optional(),
+  name: nonEmptyStringSchema,
+  schedule: cronSchema,
+  run: runSpecSchema,
+  session: sessionSchema.default("new"),
+  guard: guardSchema.optional(),
+  timeoutSeconds: timeoutSchema.optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+function formatValidationError(error) {
+  const issue = error.issues[0];
+  if (issue === undefined)
+    return "invalid job definition";
+  const field = issue.path.join(".");
+  return field.length === 0 ? issue.message : `"${field}": ${issue.message}`;
+}
+function parseWithContext(schema, value, context) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throw new Error(`${context}: ${formatValidationError(result.error)}`);
+  }
+  return result.data;
+}
+function validateRunSpec(run, context) {
+  return parseWithContext(runSpecSchema, run, context);
 }
 function validateSession(value, context) {
   if (value === undefined)
     return "new";
-  const mode = typeof value === "string" ? SESSION_MODES.find((candidate) => candidate === value) : undefined;
-  if (mode === undefined) {
-    throw new Error(`${context}: "session" must be one of ${SESSION_MODES.map((candidate) => `"${candidate}"`).join(", ")}`);
-  }
-  return mode;
+  return parseWithContext(sessionSchema, value, context);
 }
 function validateTimeout(value, context) {
   if (value === undefined)
     return;
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${context}: "timeoutSeconds" must be a non-negative integer`);
-  }
-  return value;
+  return parseWithContext(timeoutSchema, value, context);
 }
 function validateGuard(value, context) {
   if (value === undefined)
     return;
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`${context}: "guard" must be a non-empty shell command string`);
-  }
-  return value;
+  return parseWithContext(guardSchema, value, context);
 }
 function loadJobFile(file, expectedSlug) {
-  const stem = path2.basename(file).replaceAll(/\.json$/g, "");
+  const stem = path2.basename(file, ".json");
   try {
     const object = JSON.parse(readFileSync(file, "utf8"));
-    if (!isRecord(object))
-      return { ok: false, error: `${stem}.json: not a job object` };
-    const slug = stringProperty(object, "slug") ?? stem;
+    const result = jobFileSchema.safeParse(object);
+    if (!result.success) {
+      return {
+        ok: false,
+        error: `${stem}.json: ${formatValidationError(result.error)}`
+      };
+    }
+    const definition = result.data;
+    const slug = definition.slug ?? stem;
     if (slug !== stem)
       return {
         ok: false,
@@ -321,31 +352,21 @@ function loadJobFile(file, expectedSlug) {
       };
     if (expectedSlug !== undefined && slug !== expectedSlug)
       return { ok: false, error: `${stem}.json: unexpected slug` };
-    const name = nonEmptyString(object.name);
-    if (name === undefined)
-      return { ok: false, error: `${stem}.json: "name" is required` };
-    const schedule = stringProperty(object, "schedule") ?? "";
-    try {
-      parseCron(schedule);
-    } catch (error) {
-      return { ok: false, error: `${stem}.json: ${errorMessage(error)}` };
-    }
-    const run = validateRunSpec(object.run, `${stem}.json`);
-    const session = validateSession(object.session, `${stem}.json`);
-    const guard = validateGuard(object.guard, `${stem}.json`);
-    const timeoutSeconds = validateTimeout(object.timeoutSeconds, `${stem}.json`);
+    const timestamp = nowIso();
     return {
       ok: true,
       job: {
         slug,
-        name,
-        schedule,
-        run,
-        ...session !== "new" && { session },
-        ...guard !== undefined && { guard },
-        ...timeoutSeconds !== undefined && { timeoutSeconds },
-        createdAt: stringProperty(object, "createdAt") ?? nowIso(),
-        updatedAt: stringProperty(object, "updatedAt") ?? nowIso()
+        name: definition.name,
+        schedule: definition.schedule,
+        run: definition.run,
+        ...definition.session !== "new" && { session: definition.session },
+        ...definition.guard !== undefined && { guard: definition.guard },
+        ...definition.timeoutSeconds !== undefined && {
+          timeoutSeconds: definition.timeoutSeconds
+        },
+        createdAt: definition.createdAt ?? timestamp,
+        updatedAt: definition.updatedAt ?? timestamp
       }
     };
   } catch (error) {
@@ -381,21 +402,29 @@ function saveJob(workdir, job) {
 // src/registry.ts
 import { readFileSync as readFileSync2 } from "fs";
 import path3 from "path";
-function isRegistryEntry(value) {
-  if (!isRecord(value))
-    return false;
-  return stringProperty(value, "scopeId") !== undefined && stringProperty(value, "workdir") !== undefined && stringProperty(value, "enabledAt") !== undefined && stringProperty(value, "updatedAt") !== undefined && Array.isArray(value.jobs) && value.jobs.every((job) => typeof job === "string");
-}
+import { z as z2 } from "zod";
+var registryEntrySchema = z2.looseObject({
+  scopeId: z2.string(),
+  workdir: z2.string(),
+  enabledAt: z2.string(),
+  updatedAt: z2.string(),
+  jobs: z2.array(z2.string())
+});
+var registryFileSchema = z2.object({
+  version: z2.literal(1),
+  projects: z2.record(z2.string(), z2.unknown())
+});
 function loadRegistry() {
   try {
     const parsed = JSON.parse(readFileSync2(registryPath(), "utf8"));
-    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.projects)) {
+    const result = registryFileSchema.safeParse(parsed);
+    if (!result.success)
       return { version: 1, projects: {} };
-    }
     const projects = {};
-    for (const [key, value] of Object.entries(parsed.projects)) {
-      if (isRegistryEntry(value))
-        projects[key] = value;
+    for (const [key, value] of Object.entries(result.data.projects)) {
+      const entry = registryEntrySchema.safeParse(value);
+      if (entry.success)
+        projects[key] = entry.data;
     }
     return { version: 1, projects };
   } catch {
@@ -412,30 +441,21 @@ function registryEntry(workdir) {
 
 // src/runs.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-function parseRunRecord(value) {
-  const runId = stringProperty(value, "runId");
-  const slug = stringProperty(value, "slug");
-  const scopeId = stringProperty(value, "scopeId");
-  const startedAt = numberProperty(value, "startedAt");
-  const finishedAt = numberProperty(value, "finishedAt");
-  const durationMs = numberProperty(value, "durationMs");
-  const status = stringProperty(value, "status");
-  const exitCode = numberProperty(value, "exitCode");
-  const sessionId = stringProperty(value, "sessionId");
-  const startedBy = stringProperty(value, "startedBy");
-  return {
-    ...runId !== undefined && { runId },
-    ...slug !== undefined && { slug },
-    ...scopeId !== undefined && { scopeId },
-    ...startedAt !== undefined && { startedAt },
-    ...finishedAt !== undefined && { finishedAt },
-    ...durationMs !== undefined && { durationMs },
-    ...status !== undefined && { status },
-    ...exitCode !== undefined && { exitCode },
-    ...sessionId !== undefined && { sessionId },
-    ...startedBy !== undefined && { startedBy }
-  };
-}
+import { z as z3 } from "zod";
+var optionalString = z3.string().optional().catch(undefined);
+var optionalNumber = z3.number().optional().catch(undefined);
+var runRecordSchema = z3.object({
+  runId: optionalString,
+  slug: optionalString,
+  scopeId: optionalString,
+  startedAt: optionalNumber,
+  finishedAt: optionalNumber,
+  durationMs: optionalNumber,
+  status: optionalString,
+  exitCode: optionalNumber,
+  sessionId: optionalString,
+  startedBy: optionalString
+});
 function readRunRecords(scopeId, slug, limit) {
   const file = runsFile(scopeId, slug);
   if (!existsSync2(file))
@@ -447,8 +467,9 @@ function readRunRecords(scopeId, slug, limit) {
       continue;
     try {
       const value = JSON.parse(line);
-      if (isRecord(value))
-        records.push(parseRunRecord(value));
+      const result = runRecordSchema.safeParse(value);
+      if (result.success)
+        records.push(result.data);
     } catch {}
   }
   return records.slice(-limit);
@@ -999,7 +1020,13 @@ function scheduleJobOutput(input, directory) {
   } catch (error) {
     return fail(errorMessage(error));
   }
-  const run = validateRunSpec(input, "job");
+  const run = validateRunSpec({
+    prompt: input.prompt,
+    command: input.command,
+    arguments: input.arguments,
+    agent: input.agent,
+    model: input.model
+  }, "job");
   const session = validateSession(input.session, "job");
   const guard = validateGuard(input.guard, "job");
   const timeoutSeconds = validateTimeout(input.timeoutSeconds, "job");

package/dist/json.d.ts

@@ -1,4 +1 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function stringProperty(record: Record<string, unknown>, key: string): string | undefined;
-export declare function numberProperty(record: Record<string, unknown>, key: string): number | undefined;
 export declare function errorMessage(error: unknown): string;

package/dist/runs.d.ts

@@ -1,16 +1,19 @@
-export interface RunRecord {
-    runId?: string;
-    slug?: string;
-    scopeId?: string;
-    startedAt?: number;
-    finishedAt?: number;
-    durationMs?: number;
-    status?: string;
-    exitCode?: number;
-    sessionId?: string;
-    startedBy?: string;
-}
+import { z } from "zod";
+declare const runRecordSchema: z.ZodObject<{
+    runId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    slug: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    scopeId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    startedAt: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    finishedAt: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    durationMs: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    status: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    exitCode: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    sessionId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    startedBy: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type RunRecord = z.infer<typeof runRecordSchema>;
 export declare function readRunRecords(scopeId: string, slug: string, limit: number): RunRecord[];
 export declare function lastFinishedRun(records: RunRecord[]): RunRecord | undefined;
 export declare function formatRunLine(record: RunRecord): string;
 export declare function tailFile(file: string, lines: number, maxChars: number): string | undefined;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-jobs",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "opencode plugin that schedules recurring agent jobs as systemd user timers, with git-committable job definitions, run history, and session continuity",
   "type": "module",
   "engines": {
@@ -24,17 +24,14 @@
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun --format esm --external @opencode-ai/plugin && bun build src/cli.ts --outfile dist/cli.js --target node --format esm && tsc -p tsconfig.build.json",
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm --external @opencode-ai/plugin --external zod && bun build src/cli.ts --outfile dist/cli.js --target node --format esm --external zod && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run clean && npm run build",
     "format": "prettier --write .",
     "lint": "eslint",
     "typecheck": "tsc --noEmit",
     "check": "prettier --check . && eslint && tsc --noEmit",
-    "smoke": "npm run build && node scripts/smoke.mjs && node scripts/cli-smoke.mjs",
-    "release:patch": "npm version patch && npm publish",
-    "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish"
+    "smoke": "npm run build && node scripts/smoke.mjs && node scripts/cli-smoke.mjs"
   },
   "keywords": [
     "opencode",
@@ -59,7 +56,8 @@
   },
   "homepage": "https://github.com/Fraser-Grant/opencode-jobs#readme",
   "dependencies": {
-    "@opencode-ai/plugin": "^1.18.18"
+    "@opencode-ai/plugin": "^1.18.18",
+    "zod": "4.1.8"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.0.0"