oysterun 1.5.3-beta.1 → 1.5.3-beta.2

package/host-service/folder-browser.mjs

@@ -6,7 +6,15 @@ import { fileURLToPath } from "url";
 import { resolveDefaultBrowsePathAsync, resolveDirectoryPathAsync } from "./config.mjs";
 import { completeSchedulerSessionSetupPayloadForRuntime } from "./scheduler-setup-snapshot-contract.mjs";
 import { deriveBrowserRootProjectId } from "./browser-root-project-index.mjs";
-import { normalizePortableSetupSnapshot } from "./portable-scheduler-definitions.mjs";
+import {
+  normalizePortableSchedulerDefinitionsToHostTimezone,
+  normalizePortableSetupSnapshot,
+} from "./portable-scheduler-definitions.mjs";
+import {
+  computeNextScheduleRunAt,
+  getHostSystemTimezone,
+  normalizeScheduleRule,
+} from "./scheduler-rule-model.mjs";
 import { FULL_DISK_ACCESS_SETTINGS_URI as MACOS_FULL_DISK_ACCESS_SETTINGS_URI } from "./macos-permissions.mjs";
 
 const DEFAULT_LIMIT = 100;
@@ -92,47 +100,6 @@ function nowIso() {
   return new Date().toISOString();
 }
 
-function taipeiDateParts(date) {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone: "Asia/Taipei",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  }).formatToParts(date);
-  const values = Object.fromEntries(
-    parts
-      .filter((part) => part.type !== "literal")
-      .map((part) => [part.type, Number(part.value)])
-  );
-  return {
-    year: values.year,
-    month: values.month,
-    day: values.day,
-  };
-}
-
-function computeNextTaipeiDailyRunAt(time = "11:30", now = new Date()) {
-  const match = String(time || "11:30").match(/^(\d{1,2}):(\d{2})$/);
-  const hour = match ? Number(match[1]) : 11;
-  const minute = match ? Number(match[2]) : 30;
-  const parts = taipeiDateParts(now);
-  let targetUtc = Date.UTC(
-    parts.year,
-    parts.month - 1,
-    parts.day,
-    hour - 8,
-    minute,
-    0,
-    0
-  );
-  if (targetUtc <= now.getTime()) targetUtc += 24 * 60 * 60 * 1000;
-  return new Date(targetUtc).toISOString();
-}
-
 async function normalizeCopiedDemoAgentSchedulers(copiedPath) {
   const schedulersPath = join(copiedPath, ".oysterun", "schedulers.json");
   const raw = await readFile(schedulersPath, "utf8");
@@ -145,6 +112,7 @@ async function normalizeCopiedDemoAgentSchedulers(copiedPath) {
     );
   }
   const timestamp = nowIso();
+  const hostTimezone = getHostSystemTimezone();
   const projectId = deriveBrowserRootProjectId(basename(copiedPath));
   const normalizedSchedulers = payload.schedulers.map((entry) => {
     const schedule = JSON.parse(JSON.stringify(entry));
@@ -155,17 +123,23 @@ async function normalizeCopiedDemoAgentSchedulers(copiedPath) {
         "demo_agent_scheduler_invalid"
       );
     }
-    const time =
-      schedule?.schedule_rule?.timezone === "Asia/Taipei"
-        ? schedule.schedule_rule.time
-        : "11:30";
     const id = randomUUID();
     schedule.id = id;
     schedule.agent_id = projectId;
     schedule.created_by = "oysterun-demo-agent-copy";
     schedule.enabled = true;
     schedule.status = "active";
-    schedule.next_run_at = computeNextTaipeiDailyRunAt(time);
+    const hostRule = normalizeScheduleRule(
+      { ...schedule.schedule_rule, timezone: hostTimezone },
+      { timezone: hostTimezone }
+    );
+    schedule.next_run_at =
+      hostRule.type === "once"
+        ? hostRule.at
+        : computeNextScheduleRunAt(hostRule, {
+            after: timestamp,
+            timezone: hostTimezone,
+          });
     schedule.created_at = timestamp;
     schedule.updated_at = timestamp;
     const portableSetupSnapshot = normalizePortableSetupSnapshot(
@@ -195,9 +169,23 @@ async function normalizeCopiedDemoAgentSchedulers(copiedPath) {
     schedulersPath,
     `${JSON.stringify({ version: 1, schedulers: normalizedSchedulers }, null, 2)}\n`
   );
+  const timezoneNormalization =
+    normalizePortableSchedulerDefinitionsToHostTimezone(copiedPath, {
+      hostTimezone,
+      source: "demo_agent_copy",
+      now: timestamp,
+    });
+  const finalPayload = JSON.parse(await readFile(schedulersPath, "utf8"));
   return {
-    scheduler_count: normalizedSchedulers.length,
-    scheduler_ids: normalizedSchedulers.map((entry) => entry.id),
+    scheduler_count: finalPayload.schedulers.length,
+    scheduler_ids: finalPayload.schedulers.map((entry) => entry.id),
+    timezone_normalization: {
+      status: timezoneNormalization.status,
+      host_timezone: timezoneNormalization.host_timezone,
+      corrected_count: timezoneNormalization.corrected_count,
+    },
+    timezone_correction_count: timezoneNormalization.corrected_count,
+    timezone_corrections: timezoneNormalization.corrections,
   };
 }
 
@@ -523,6 +511,12 @@ export async function copyDemoAgent({
     copied_path: copiedPath,
     portable_scheduler_count: schedulerRegistration.scheduler_count,
     portable_scheduler_ids: schedulerRegistration.scheduler_ids,
+    portable_scheduler_timezone_normalization:
+      schedulerRegistration.timezone_normalization,
+    portable_scheduler_timezone_correction_count:
+      schedulerRegistration.timezone_correction_count || 0,
+    portable_scheduler_timezone_corrections:
+      schedulerRegistration.timezone_corrections || [],
     start_session_available: true,
   };
 }

package/host-service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oysterun-host-service",
-  "version": "1.5.3-beta.1",
+  "version": "1.5.3-beta.2",
   "type": "module",
   "description": "Oysterun host service — runs on Mac mini, manages Claude Code sessions",
   "scripts": {

package/host-service/portable-scheduler-definitions.mjs

@@ -12,6 +12,7 @@ import { completeSchedulerSessionSetupPayloadForRuntime } from "./scheduler-setu
 import { deriveBrowserRootProjectId } from "./browser-root-project-index.mjs";
 import {
   computeNextScheduleRunAt,
+  getHostSystemTimezone,
   normalizeScheduleRule,
 } from "./scheduler-rule-model.mjs";
 
@@ -330,6 +331,151 @@ function writePortableFile(filePath, payload) {
   renameSync(tmpPath, filePath);
 }
 
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function existingTimezoneFields(schedule) {
+  const fields = [];
+  const add = (container, key, field) => {
+    if (!isObjectRecord(container) || !hasOwn(container, key)) return;
+    const timezone = normalizeOptionalString(container[key]);
+    fields.push({ container, key, field, timezone });
+  };
+  add(schedule, "timezone", "definition.timezone");
+  add(schedule.schedule_rule, "timezone", "definition.schedule_rule.timezone");
+  add(schedule.metadata, "timezone", "definition.metadata.timezone");
+  add(
+    schedule.metadata?.schedule_rule,
+    "timezone",
+    "definition.metadata.schedule_rule.timezone"
+  );
+  return fields;
+}
+
+function buildPortableTimezoneCorrection({
+  agentFolder,
+  schedule,
+  fields,
+  filePath,
+  hostTimezone,
+  source,
+}) {
+  const mismatched = fields.find((field) => field.timezone !== hostTimezone);
+  const firstKnown = fields.find((field) => field.timezone);
+  const oldTimezone = mismatched?.timezone || firstKnown?.timezone || null;
+  const timePreserved =
+    normalizeOptionalString(schedule.schedule_rule?.time) ||
+    normalizeOptionalString(schedule.metadata?.schedule_rule?.time) ||
+    normalizeOptionalString(schedule.schedule_rule?.at) ||
+    null;
+  return {
+    agent_folder: agentFolder,
+    schedule_id: normalizeOptionalString(schedule.id) || null,
+    old_timezone: oldTimezone,
+    host_timezone: hostTimezone,
+    time_preserved: timePreserved,
+    portable_file_path: filePath,
+    source,
+    message: `Portable scheduler timezone normalized from ${
+      oldTimezone || "unspecified"
+    } to ${hostTimezone}; scheduled time preserved as ${
+      timePreserved || "absolute timestamp"
+    }.`,
+  };
+}
+
+function recomputePortableNextRunAtForHost(schedule, { hostTimezone, now }) {
+  if (!hasOwn(schedule, "next_run_at")) return schedule.next_run_at;
+  if (!isObjectRecord(schedule.schedule_rule)) return schedule.next_run_at;
+  const hostRule = { ...schedule.schedule_rule, timezone: hostTimezone };
+  const normalizedRule = normalizeScheduleRule(hostRule, {
+    timezone: hostTimezone,
+  });
+  if (normalizedRule.type === "once") {
+    return normalizeOptionalString(schedule.next_run_at) || normalizedRule.at;
+  }
+  return computeNextScheduleRunAt(normalizedRule, {
+    after: now,
+    timezone: hostTimezone,
+  });
+}
+
+export function normalizePortableSchedulerDefinitionsToHostTimezone(
+  agentFolder,
+  {
+    hostTimezone = getHostSystemTimezone(),
+    source = "browser_root_portable_scheduler_import",
+    now = null,
+    clock = () => new Date(),
+  } = {}
+) {
+  const realFolder = realpathSync(
+    normalizeRequiredString(agentFolder, "agentFolder")
+  );
+  const normalizedHostTimezone = normalizeScheduleRule(
+    { type: "daily", time: "00:00", timezone: hostTimezone },
+    { timezone: hostTimezone }
+  ).timezone;
+  const filePath = getPortableSchedulersJsonPath(realFolder);
+  const payload = readPortableFile(filePath);
+  const correctionTime = nowIso(now === null ? clock : () => now);
+  let changed = false;
+  const corrections = [];
+  const schedulers = payload.schedulers.map((entry) => {
+    if (!isObjectRecord(entry)) return entry;
+    const schedule = deepCloneJson(entry, "portable scheduler definition");
+    const fields = existingTimezoneFields(schedule);
+    const mismatched = fields.filter(
+      (field) => field.timezone !== normalizedHostTimezone
+    );
+    if (mismatched.length === 0) return schedule;
+
+    for (const field of fields) {
+      if (field.timezone !== normalizedHostTimezone) {
+        field.container[field.key] = normalizedHostTimezone;
+      }
+    }
+    if (hasOwn(schedule, "next_run_at")) {
+      schedule.next_run_at = recomputePortableNextRunAtForHost(schedule, {
+        hostTimezone: normalizedHostTimezone,
+        now: correctionTime,
+      });
+    }
+    schedule.updated_at = correctionTime;
+    corrections.push(
+      buildPortableTimezoneCorrection({
+        agentFolder: realFolder,
+        schedule,
+        fields,
+        filePath,
+        hostTimezone: normalizedHostTimezone,
+        source,
+      })
+    );
+    changed = true;
+    return schedule;
+  });
+  if (changed) {
+    writePortableFile(filePath, {
+      ...payload,
+      schedulers,
+    });
+  }
+  return {
+    status: changed
+      ? "portable_scheduler_timezone_normalized"
+      : "portable_scheduler_timezone_already_host",
+    agent_folder: realFolder,
+    portable_file_path: filePath,
+    host_timezone: normalizedHostTimezone,
+    scheduler_count: payload.schedulers.length,
+    corrected_count: corrections.length,
+    corrections,
+    changed,
+  };
+}
+
 function normalizeBrowserRootProjectEntry(entry) {
   if (!isObjectRecord(entry)) {
     throw new Error("Browser Root project entry must be an object");
@@ -450,6 +596,66 @@ export class PortableSchedulerDefinitionStore {
     return filePath;
   }
 
+  normalizeDefinitionsForFolderToHostTimezone(
+    agentFolder,
+    {
+      hostTimezone = getHostSystemTimezone(),
+      source = "browser_root_portable_scheduler_import",
+    } = {}
+  ) {
+    const result = normalizePortableSchedulerDefinitionsToHostTimezone(
+      agentFolder,
+      {
+        hostTimezone,
+        source,
+        clock: this.clock,
+      }
+    );
+    if (result.changed) this.invalidateScheduleCache();
+    return result;
+  }
+
+  normalizeBrowserRootPortableSchedulersToHostTimezone({
+    hostTimezone = getHostSystemTimezone(),
+    source = "browser_root_portable_scheduler_import",
+  } = {}) {
+    const projects = this.getBrowserRootProjectFolders();
+    const results = [];
+    const corrections = [];
+    let schedulerCount = 0;
+    for (const project of projects) {
+      const result = this.normalizeDefinitionsForFolderToHostTimezone(
+        project.agent_folder,
+        { hostTimezone, source }
+      );
+      schedulerCount += result.scheduler_count;
+      corrections.push(...result.corrections);
+      results.push({
+        project_id: project.project_id,
+        agent_folder: project.agent_folder,
+        portable_file_path: result.portable_file_path,
+        scheduler_count: result.scheduler_count,
+        corrected_count: result.corrected_count,
+        status: result.status,
+      });
+    }
+    return {
+      status:
+        corrections.length > 0
+          ? "browser_root_portable_scheduler_timezone_normalized"
+          : "browser_root_portable_scheduler_timezone_already_host",
+      host_timezone: normalizeScheduleRule(
+        { type: "daily", time: "00:00", timezone: hostTimezone },
+        { timezone: hostTimezone }
+      ).timezone,
+      project_count: projects.length,
+      scheduler_count: schedulerCount,
+      corrected_count: corrections.length,
+      corrections,
+      results,
+    };
+  }
+
   buildPortableHash(definition) {
     return hashPortableScheduleDefinition({
       id: definition.id,

package/host-service/scheduler-service.mjs

@@ -1120,6 +1120,29 @@ export class SchedulerService {
       .map((schedule) => this.serializeHostScheduleForDashboardUi(schedule));
   }
 
+  normalizeBrowserRootPortableSchedules({ hostTimezone = null } = {}) {
+    this.initialize();
+    const timezoneNormalization =
+      this.portableDefinitionStore.normalizeBrowserRootPortableSchedulersToHostTimezone(
+        {
+          hostTimezone: hostTimezone || getHostSystemTimezone(),
+          source: "browser_root_portable_scheduler_import",
+        }
+      );
+    return {
+      status: timezoneNormalization.status,
+      host_timezone: timezoneNormalization.host_timezone,
+      project_count: timezoneNormalization.project_count,
+      scheduler_count: timezoneNormalization.scheduler_count,
+      timezone_correction_count: timezoneNormalization.corrected_count,
+      timezone_corrections: timezoneNormalization.corrections,
+      timezone_correction_notifications: timezoneNormalization.corrections.map(
+        (correction) => correction.message
+      ),
+      results: timezoneNormalization.results,
+    };
+  }
+
   getHostScheduleForDashboard(scheduleId) {
     return this.serializeHostScheduleForDashboardUi(
       this.requireHostSchedule(scheduleId)

package/host-service/server.mjs

@@ -14811,11 +14811,28 @@ const server = createServer(async (req, res) => {
           reason: "scheduler_owner_refresh",
           rebuildWatchers: true,
         });
+        const timezoneNormalization =
+          schedulerService.normalizeBrowserRootPortableSchedules({
+            hostTimezone: getHostSystemTimezone(),
+          });
         return respond(res, 200, {
           status: "scheduler_browser_root_refreshed",
           browser_root: projectIndex.root,
           project_count: projectIndex.projects.length,
           diagnostic_count: projectIndex.diagnostics.length,
+          timezone_normalization: {
+            status: timezoneNormalization.status,
+            host_timezone: timezoneNormalization.host_timezone,
+            project_count: timezoneNormalization.project_count,
+            scheduler_count: timezoneNormalization.scheduler_count,
+            corrected_count:
+              timezoneNormalization.timezone_correction_count,
+          },
+          timezone_correction_count:
+            timezoneNormalization.timezone_correction_count,
+          timezone_corrections: timezoneNormalization.timezone_corrections,
+          timezone_correction_notifications:
+            timezoneNormalization.timezone_correction_notifications,
           schedules: schedulerService.listHostSchedulesForDashboard(),
           project_registration_issues:
             buildBrowserRootProjectRegistrationIssues(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oysterun",
-  "version": "1.5.3-beta.1",
+  "version": "1.5.3-beta.2",
   "type": "module",
   "description": "Oysterun Host installer and local service",
   "bin": {