fix: adapt automations to dev rebase

Author: joshue031

packages/app/src/pages/automations.tsx

@@ -292,7 +292,7 @@ export default function AutomationsPage() {
   }
 
   const loadRuns = async () => {
-    const result = await sdk.client.automation.runs({ limit: 100 })
+    const result = await sdk.client.automation.runs({ limit: "100" })
     return result.data ?? []
   }
 

packages/opencode/src/automation/automation.ts

@@ -5,6 +5,7 @@ import * as Log from "@opencode-ai/core/util/log"
 import { and, desc, eq, inArray, lte, sql } from "drizzle-orm"
 import { Database } from "@/storage/db"
 import { Instance } from "@/project/instance"
+import { InstanceRef } from "@/effect/instance-ref"
 import { EffectBridge } from "@/effect/bridge"
 import { InstanceState } from "@/effect/instance-state"
 import { ProjectID } from "@/project/schema"
@@ -18,8 +19,8 @@ import { SessionSummary } from "@/session/summary"
 import { SessionStatus } from "@/session/status"
 import type { FileDiff } from "@/snapshot"
 import { Worktree } from "@/worktree"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
+import { zod } from "@opencode-ai/core/effect-zod"
+import { withStatics } from "@opencode-ai/core/schema"
 import { Cause, Context, Effect, Exit, Layer, Option, Schema, Types } from "effect"
 import { AutomationFindingTable, AutomationRunTable, AutomationTable } from "./automation.sql"
 import { AutomationFindingID, AutomationID, AutomationRunID } from "./schema"
@@ -34,7 +35,7 @@ export type Weekday = Schema.Schema.Type<typeof Weekday>
 export const ScheduleConfig = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("interval"),
-    everyMinutes: Schema.Number,
+    everyMinutes: Schema.Finite,
   }),
   Schema.Struct({
     type: Schema.Literal("daily"),
@@ -77,18 +78,18 @@ export const RunStatus = Schema.Literals([
 export type RunStatus = Schema.Schema.Type<typeof RunStatus>
 
 const DiffStats = Schema.Struct({
-  additions: Schema.Number,
-  deletions: Schema.Number,
-  files: Schema.Number,
+  additions: Schema.Finite,
+  deletions: Schema.Finite,
+  files: Schema.Finite,
 })
 
 const Time = Schema.Struct({
-  created: Schema.Number,
-  updated: Schema.Number,
-  lastRun: Schema.optional(Schema.Number),
-  nextRun: Schema.optional(Schema.Number),
-  starts: Schema.optional(Schema.Number),
-  ends: Schema.optional(Schema.Number),
+  created: Schema.Finite,
+  updated: Schema.Finite,
+  lastRun: Schema.optional(Schema.Finite),
+  nextRun: Schema.optional(Schema.Finite),
+  starts: Schema.optional(Schema.Finite),
+  ends: Schema.optional(Schema.Finite),
 })
 
 export const Finding = Schema.Struct({
@@ -100,8 +101,8 @@ export const Finding = Schema.Struct({
   filesChanged: Schema.mutable(Schema.Array(Schema.String)),
   recommendedNextAction: Schema.optional(Schema.String),
   time: Schema.Struct({
-    created: Schema.Number,
-    updated: Schema.Number,
+    created: Schema.Finite,
+    updated: Schema.Finite,
   }),
 })
   .annotate({ identifier: "AutomationFinding" })
@@ -123,7 +124,7 @@ export const Info = Schema.Struct({
   reasoningEffort: Schema.optional(Schema.Literals(["none", "low", "medium", "high"])),
   permissionProfile: PermissionProfile,
   notificationBehavior: Schema.Literals(["inbox", "auto_archive_no_findings"]),
-  maxRuntimeMinutes: Schema.optional(Schema.Number),
+  maxRuntimeMinutes: Schema.optional(Schema.Finite),
   time: Time,
 })
   .annotate({ identifier: "Automation" })
@@ -145,17 +146,17 @@ export const RunInfo = Schema.Struct({
   branchName: Schema.optional(Schema.String),
   summary: Schema.optional(Schema.String),
   result: Schema.optional(Schema.Literals(["findings", "no_findings", "needs_approval", "failed"])),
-  findingsCount: Schema.Number,
+  findingsCount: Schema.Finite,
   diffStats: Schema.optional(DiffStats),
   error: Schema.optional(Schema.String),
   time: Schema.Struct({
-    created: Schema.Number,
-    updated: Schema.Number,
-    queued: Schema.Number,
-    started: Schema.optional(Schema.Number),
-    completed: Schema.optional(Schema.Number),
-    read: Schema.optional(Schema.Number),
-    archived: Schema.optional(Schema.Number),
+    created: Schema.Finite,
+    updated: Schema.Finite,
+    queued: Schema.Finite,
+    started: Schema.optional(Schema.Finite),
+    completed: Schema.optional(Schema.Finite),
+    read: Schema.optional(Schema.Finite),
+    archived: Schema.optional(Schema.Finite),
   }),
 })
   .annotate({ identifier: "AutomationRun" })
@@ -174,9 +175,9 @@ export const CreateInput = Schema.Struct({
   reasoningEffort: Schema.optional(Schema.Literals(["none", "low", "medium", "high"])),
   permissionProfile: Schema.optional(PermissionProfile),
   notificationBehavior: Schema.optional(Schema.Literals(["inbox", "auto_archive_no_findings"])),
-  maxRuntimeMinutes: Schema.optional(Schema.Number),
-  startsAt: Schema.optional(Schema.Number),
-  endsAt: Schema.optional(Schema.Number),
+  maxRuntimeMinutes: Schema.optional(Schema.Finite),
+  startsAt: Schema.optional(Schema.Finite),
+  endsAt: Schema.optional(Schema.Finite),
 })
   .annotate({ identifier: "AutomationCreateInput" })
   .pipe(withStatics((s) => ({ zod: zod(s) })))
@@ -194,9 +195,9 @@ export const UpdateInput = Schema.Struct({
   reasoningEffort: Schema.optional(Schema.Literals(["none", "low", "medium", "high"])),
   permissionProfile: Schema.optional(PermissionProfile),
   notificationBehavior: Schema.optional(Schema.Literals(["inbox", "auto_archive_no_findings"])),
-  maxRuntimeMinutes: Schema.optional(Schema.Number),
-  startsAt: Schema.optional(Schema.Number),
-  endsAt: Schema.optional(Schema.Number),
+  maxRuntimeMinutes: Schema.optional(Schema.Finite),
+  startsAt: Schema.optional(Schema.Finite),
+  endsAt: Schema.optional(Schema.Finite),
 })
   .annotate({ identifier: "AutomationUpdateInput" })
   .pipe(withStatics((s) => ({ zod: zod(s) })))
@@ -206,7 +207,7 @@ export const ListRunsInput = Schema.Struct({
   automationID: Schema.optional(AutomationID),
   inbox: Schema.optional(Schema.Boolean),
   archived: Schema.optional(Schema.Boolean),
-  limit: Schema.optional(Schema.Number),
+  limit: Schema.optional(Schema.Finite),
 })
   .annotate({ identifier: "AutomationListRunsInput" })
   .pipe(withStatics((s) => ({ zod: zod(s) })))
@@ -1035,7 +1036,7 @@ export const layer = Layer.effect(
                 details:
                   [finalOutput.summary, finalOutput.diffSummary].filter(Boolean).join("\n\n") ||
                   "Automation completed.",
-                filesChanged: diffs.map((diff) => diff.file),
+                filesChanged: diffs.map((diff) => diff.file).filter((file): file is string => file !== undefined),
               },
             ]
       const nextRunAt = computeNextRun({
@@ -1217,12 +1218,16 @@ export const layer = Layer.effect(
             )
           : runPromptEffect(automation, runID)
         const result = worktreeInfo
-          ? yield* Effect.promise(async () => {
-              const nested = await Instance.provide({
-                directory: worktreeInfo!.directory,
-                fn: () => Effect.runPromise(task.pipe(Effect.provide(WorktreeRunLayer))),
-              })
-              return await nested
+          ? yield* Effect.gen(function* () {
+              const current = yield* InstanceState.context
+              const ctx = { ...current, directory: worktreeInfo!.directory }
+              return yield* Effect.promise(() =>
+                Instance.restore(ctx, () =>
+                  Effect.runPromise(
+                    task.pipe(Effect.provideService(InstanceRef, ctx), Effect.provide(WorktreeRunLayer)),
+                  ),
+                ),
+              )
             })
           : yield* task
         const structured =

packages/opencode/src/automation/schema.ts

@@ -1,33 +1,36 @@
 import { Schema } from "effect"
 import { Identifier } from "@/id/id"
-import { zod, ZodOverride } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
+import { zod } from "@opencode-ai/core/effect-zod"
+import { withStatics } from "@opencode-ai/core/schema"
 
-export const AutomationID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("automation") }).pipe(
-  Schema.brand("AutomationID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("automation", id)),
-    zod: zod(s),
+const automationIdSchema = Schema.String.check(Schema.isStartsWith("aut")).pipe(Schema.brand("AutomationID"))
+export type AutomationID = typeof automationIdSchema.Type
+
+export const AutomationID = automationIdSchema.pipe(
+  withStatics((schema: typeof automationIdSchema) => ({
+    ascending: (id?: string) => schema.make(Identifier.ascending("automation", id)),
+    zod: zod(schema),
   })),
 )
-export type AutomationID = Schema.Schema.Type<typeof AutomationID>
 
-export const AutomationRunID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("automationRun") }).pipe(
-  Schema.brand("AutomationRunID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("automationRun", id)),
-    zod: zod(s),
+const automationRunIdSchema = Schema.String.check(Schema.isStartsWith("arn")).pipe(Schema.brand("AutomationRunID"))
+export type AutomationRunID = typeof automationRunIdSchema.Type
+
+export const AutomationRunID = automationRunIdSchema.pipe(
+  withStatics((schema: typeof automationRunIdSchema) => ({
+    ascending: (id?: string) => schema.make(Identifier.ascending("automationRun", id)),
+    zod: zod(schema),
   })),
 )
-export type AutomationRunID = Schema.Schema.Type<typeof AutomationRunID>
 
-export const AutomationFindingID = Schema.String.annotate({
-  [ZodOverride]: Identifier.schema("automationFinding"),
-}).pipe(
+const automationFindingIdSchema = Schema.String.check(Schema.isStartsWith("afn")).pipe(
   Schema.brand("AutomationFindingID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("automationFinding", id)),
-    zod: zod(s),
+)
+export type AutomationFindingID = typeof automationFindingIdSchema.Type
+
+export const AutomationFindingID = automationFindingIdSchema.pipe(
+  withStatics((schema: typeof automationFindingIdSchema) => ({
+    ascending: (id?: string) => schema.make(Identifier.ascending("automationFinding", id)),
+    zod: zod(schema),
   })),
 )
-export type AutomationFindingID = Schema.Schema.Type<typeof AutomationFindingID>

packages/opencode/src/server/routes/instance/httpapi/groups/global.ts

@@ -45,7 +45,7 @@ const LiveAutomationRun = Schema.Struct({
 }).annotate({ identifier: "LiveAutomationRun" })
 
 const GlobalAutomationRunning = Schema.Struct({
-  count: Schema.Number,
+  count: Schema.Finite,
   runs: Schema.Array(LiveAutomationRun),
 })
 

packages/opencode/src/server/routes/instance/httpapi/handlers/automation.ts

@@ -44,14 +44,14 @@ export const automationHandlers = HttpApiBuilder.group(InstanceHttpApi, "automat
 
     const read = Effect.fn("AutomationHttpApi.read")(function* (ctx: {
       params: { runID: AutomationRunID }
-      payload?: typeof RunReadPayload.Type
+      payload: typeof RunReadPayload.Type | void
     }) {
       return yield* mapNotFound(automation.markRunRead(ctx.params.runID, ctx.payload?.read))
     })
 
     const archive = Effect.fn("AutomationHttpApi.archive")(function* (ctx: {
       params: { runID: AutomationRunID }
-      payload?: typeof RunArchivePayload.Type
+      payload: typeof RunArchivePayload.Type | void
     }) {
       return yield* mapNotFound(automation.archiveRun(ctx.params.runID, ctx.payload?.archived))
     })