@zythum02/fello-server 0.1.28 → 0.1.29

package/out/server/main.js

@@ -2,10 +2,10 @@
 
 // src/backend/backend.ts
 import Fuse from "fuse.js";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { spawn as spawnPty } from "node-pty";
 import { omit } from "es-toolkit";
-import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID5 } from "crypto";
 import {
   chmod,
   mkdir as mkdir2,
@@ -19,9 +19,9 @@ import {
   copyFile
 } from "fs/promises";
 import * as mimeTypes3 from "mime-types";
-import { dirname as dirname4, join as join7, relative as relative5, extname as extname2, basename as basename3 } from "path";
-import * as fs2 from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname6, join as join9, relative as relative5, extname as extname2, basename as basename3 } from "path";
+import * as fs3 from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { createRequire } from "module";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -129,6 +129,7 @@ function readSettings() {
             return nextHeaders;
           })();
           const contextWindowTokens = typeof cfg?.contextWindowTokens === "number" ? cfg.contextWindowTokens : void 0;
+          const modelIdTemplate = typeof cfg?.modelIdTemplate === "string" && cfg.modelIdTemplate.trim() ? cfg.modelIdTemplate.trim() : void 0;
           next[id] = {
             type,
             provider,
@@ -137,7 +138,8 @@ function readSettings() {
             headers,
             disabled,
             order,
-            contextWindowTokens
+            contextWindowTokens,
+            modelIdTemplate
           };
         }
       }
@@ -387,7 +389,8 @@ var storageOps = {
             apiKey: agentMeta.apiKey,
             headers: Object.assign({}, agentMeta.headers),
             disabled: agentMeta.disabled,
-            contextWindowTokens: agentMeta.contextWindowTokens
+            contextWindowTokens: agentMeta.contextWindowTokens,
+            modelIdTemplate: agentMeta.modelIdTemplate
           };
         }
         throw new Error("Invalid agent type.");
@@ -461,7 +464,8 @@ var storageOps = {
               headers: Object.assign({}, agent.headers || {}),
               disabled: agent.disabled,
               order: idx,
-              contextWindowTokens: agent.contextWindowTokens !== void 0 ? Number.isInteger(agent.contextWindowTokens) && agent.contextWindowTokens > 0 ? agent.contextWindowTokens : void 0 : void 0
+              contextWindowTokens: agent.contextWindowTokens !== void 0 ? Number.isInteger(agent.contextWindowTokens) && agent.contextWindowTokens > 0 ? agent.contextWindowTokens : void 0 : void 0,
+              modelIdTemplate: typeof agent.modelIdTemplate === "string" && agent.modelIdTemplate.trim() ? agent.modelIdTemplate.trim() : void 0
             };
           } else {
             throw new Error("Invalid agent type.");
@@ -2191,6 +2195,13 @@ function isOpenAICompatibleModelsResponse(value) {
   if (maybe.data === void 0) return true;
   return Array.isArray(maybe.data);
 }
+function applyModelIdTemplate(template, modelItem) {
+  return template.replace(/\{(\w+)\}/g, (_match, fieldName) => {
+    const value = modelItem[fieldName];
+    if (value === void 0 || value === null) return _match;
+    return String(value);
+  });
+}
 var AgentDescription = "Fello/0.1.1 CodeAgent OpenaiCompatibleAgent opencode codex";
 var AVAILABLE_COMMANDS = [
   { name: "compact", description: "Compress conversation context" }
@@ -2204,6 +2215,7 @@ var OpenaiCompatibleAgent = class {
   apiKey;
   headers;
   contextWindowTokens;
+  modelIdTemplate;
   modelsCache = null;
   modelsFetchedAt = 0;
   modelsPending = null;
@@ -2217,6 +2229,7 @@ var OpenaiCompatibleAgent = class {
     this.agentId = options.id;
     this.headers = options.headers || {};
     this.contextWindowTokens = options.contextWindowTokens ?? DEFAULT_CONTEXT_WINDOW_TOKENS;
+    this.modelIdTemplate = options.modelIdTemplate;
     this.provider = createOpenAICompatible({
       name: "openai-compatible",
       baseURL: this.baseUrl,
@@ -2283,7 +2296,10 @@ var OpenaiCompatibleAgent = class {
     const entries = Array.isArray(payload.data) ? payload.data : [];
     const models = entries.map((item) => {
       if (typeof item?.id !== "string" || item.id.trim().length === 0) return null;
-      return { modelId: item.id, name: item.id };
+      const rawId = item.id.trim();
+      const modelId = this.modelIdTemplate ? applyModelIdTemplate(this.modelIdTemplate, item) : rawId;
+      if (!modelId.trim()) return null;
+      return { modelId, name: modelId };
     }).filter((item) => item !== null);
     return this.toSessionModelState(models);
   }
@@ -4413,97 +4429,152 @@ var ILinkBridge = class _ILinkBridge {
   }
 };
 
-// src/backend/watcher.ts
-import watcher from "@parcel/watcher";
-import { relative as relative3 } from "path";
-function isFileWatcherEnabled() {
-  return storageOps.getSettings().fileWatcher?.enabled ?? true;
-}
-var subscriptions = /* @__PURE__ */ new Map();
-var MAX_BATCH_CHANGES = 1e3;
-var IGNORE = [
-  "**/.git/**",
-  "**/.svn/**",
-  "**/.hg/**",
-  "**/node_modules/**",
-  "**/bower_components/**",
-  "**/.cache/**",
-  "**/venv/**",
-  "**/.venv/**",
-  "**/vendor/**",
-  "**/__pycache__/**"
-];
-var sendEvent = () => false;
-function initWatcher(emitter) {
-  sendEvent = emitter;
-  void syncWatchers();
-}
-async function syncWatchers() {
-  const enabled = isFileWatcherEnabled();
-  const projects = storageOps.listProjects();
-  const currentProjects = new Map(projects.map((p) => [p.id, p]));
-  if (!enabled) {
-    for (const [projectId, subscription] of subscriptions.entries()) {
-      await subscription.unsubscribe();
-      subscriptions.delete(projectId);
+// src/backend/automation/store.ts
+import { join as join6, dirname as dirname3 } from "path";
+import { homedir as homedir2 } from "os";
+import {
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  rmSync as rmSync3,
+  existsSync as existsSync3,
+  statSync as statSync2
+} from "fs";
+var AUTOMATIONS_DIR = join6(homedir2(), ".fello", "automations");
+mkdirSync4(AUTOMATIONS_DIR, { recursive: true });
+var store = {
+  scheduleDir(scheduleId) {
+    return join6(AUTOMATIONS_DIR, scheduleId);
+  },
+  scheduleConfigPath(scheduleId) {
+    return join6(this.scheduleDir(scheduleId), "schedule.json");
+  },
+  tasksDir(scheduleId) {
+    return join6(this.scheduleDir(scheduleId), "tasks");
+  },
+  taskDir(scheduleId, taskId) {
+    return join6(this.tasksDir(scheduleId), taskId);
+  },
+  taskMetaPath(scheduleId, taskId) {
+    return join6(this.taskDir(scheduleId, taskId), "task.json");
+  },
+  listSchedules() {
+    if (!existsSync3(AUTOMATIONS_DIR)) return [];
+    const dirs = readdirSync2(AUTOMATIONS_DIR);
+    const list = [];
+    for (const dir of dirs) {
+      try {
+        const raw = JSON.parse(readFileSync3(this.scheduleConfigPath(dir), "utf-8"));
+        list.push(raw);
+      } catch {
+      }
     }
-    return;
-  }
-  for (const [projectId, subscription] of subscriptions.entries()) {
-    if (!currentProjects.has(projectId)) {
-      await subscription.unsubscribe();
-      subscriptions.delete(projectId);
+    list.sort((a, b) => b.updatedAt - a.updatedAt);
+    return list;
+  },
+  getSchedule(scheduleId) {
+    try {
+      return JSON.parse(readFileSync3(this.scheduleConfigPath(scheduleId), "utf-8"));
+    } catch {
+      return null;
     }
-  }
-  for (const [projectId, project] of currentProjects) {
-    if (!subscriptions.has(projectId)) {
-      await createWatcher(projectId, project.cwd);
+  },
+  saveSchedule(schedule) {
+    const dir = this.scheduleDir(schedule.id);
+    mkdirSync4(dir, { recursive: true });
+    mkdirSync4(this.tasksDir(schedule.id), { recursive: true });
+    writeFileSync3(this.scheduleConfigPath(schedule.id), JSON.stringify(schedule, null, 2));
+  },
+  deleteSchedule(scheduleId) {
+    const dir = this.scheduleDir(scheduleId);
+    if (existsSync3(dir)) {
+      rmSync3(dir, { recursive: true, force: true });
     }
-  }
-}
-async function createWatcher(projectId, cwd) {
-  const changes = /* @__PURE__ */ new Set();
-  let overflowed = false;
-  let timeout = null;
-  const flush = () => {
-    if (changes.size > 0) {
-      sendEvent("fs-changed", { projectId, changes: Array.from(changes) });
-      changes.clear();
-      overflowed = false;
+  },
+  listTasks(scheduleId) {
+    const dir = this.tasksDir(scheduleId);
+    if (!existsSync3(dir)) return [];
+    const dirs = readdirSync2(dir);
+    const list = [];
+    for (const d of dirs) {
+      try {
+        const raw = JSON.parse(readFileSync3(this.taskMetaPath(scheduleId, d), "utf-8"));
+        list.push(raw);
+      } catch {
+      }
     }
-  };
-  const onChange = (path2) => {
-    if (!overflowed) {
-      if (changes.size < MAX_BATCH_CHANGES) {
-        changes.add(path2);
+    list.sort((a, b) => b.startedAt - a.startedAt);
+    return list;
+  },
+  getTask(scheduleId, taskId) {
+    try {
+      return JSON.parse(readFileSync3(this.taskMetaPath(scheduleId, taskId), "utf-8"));
+    } catch {
+      return null;
+    }
+  },
+  saveTask(scheduleId, task) {
+    const dir = this.taskDir(scheduleId, task.id);
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync3(this.taskMetaPath(scheduleId, task.id), JSON.stringify(task, null, 2));
+  },
+  deleteTask(scheduleId, taskId) {
+    const dir = this.taskDir(scheduleId, taskId);
+    if (existsSync3(dir)) {
+      rmSync3(dir, { recursive: true, force: true });
+    }
+  },
+  listTaskFiles(scheduleId, taskId) {
+    const dir = this.taskDir(scheduleId, taskId);
+    if (!existsSync3(dir)) return [];
+    const entries = readdirSync2(dir);
+    return entries.filter((f) => f !== "task.json").map((f) => {
+      const fullPath = join6(dir, f);
+      const s = statSync2(fullPath);
+      if (s.isDirectory()) {
+        return this._listDirRecursive(fullPath, f);
+      }
+      return f;
+    }).flat().sort();
+  },
+  _listDirRecursive(dir, prefix) {
+    const result = [];
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      const full = join6(dir, entry);
+      const s = statSync2(full);
+      if (s.isDirectory()) {
+        result.push(...this._listDirRecursive(full, join6(prefix, entry)));
       } else {
-        overflowed = true;
-        changes.clear();
-        changes.add(".");
+        result.push(join6(prefix, entry));
       }
     }
-    if (timeout) clearTimeout(timeout);
-    timeout = setTimeout(flush, 500);
-  };
-  try {
-    const subscription = await watcher.subscribe(
-      cwd,
-      (err, events) => {
-        if (err) {
-          console.error(`[Watcher] Error for ${projectId} (${cwd}):`, err);
-          return;
-        }
-        for (const event of events) {
-          onChange(toPosixPath(relative3(cwd, event.path)));
-        }
-      },
-      { ignore: IGNORE }
-    );
-    subscriptions.set(projectId, subscription);
-  } catch (err) {
-    console.error(`[Watcher] Failed to subscribe for ${projectId} (${cwd}):`, err);
+    return result;
+  },
+  readTaskFile(scheduleId, taskId, filePath) {
+    const base = this.taskDir(scheduleId, taskId);
+    const fullPath = join6(base, filePath);
+    if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
+    if (!existsSync3(fullPath)) throw new Error("File not found");
+    return readFileSync3(fullPath, "utf-8");
+  },
+  writeTaskFile(scheduleId, taskId, filePath, content) {
+    const base = this.taskDir(scheduleId, taskId);
+    const fullPath = join6(base, filePath);
+    if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
+    mkdirSync4(dirname3(fullPath), { recursive: true });
+    writeFileSync3(fullPath, content);
   }
-}
+};
+
+// src/backend/automation/scheduler.ts
+import { CronJob } from "cron";
+
+// src/backend/automation/runner.ts
+import { join as join8, dirname as dirname5 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/backend/skills.ts
 import * as fs from "fs";
@@ -4705,6 +4776,399 @@ async function installSkill(source, slug) {
   }
 }
 
+// src/backend/automation/runner.ts
+import fs2 from "fs";
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+var sendEvent = null;
+function initRunner(emitter) {
+  sendEvent = emitter;
+}
+function resolveAgentInfo(agentId) {
+  const settings = storageOps.getSettings();
+  const agent = settings.agents.find((a) => a.id === agentId);
+  if (!agent) throw new Error(`Unknown agent: ${agentId}`);
+  if (agent.type === "stdio") {
+    const command = agent.command.trim();
+    if (!command) throw new Error(`Agent "${agent.id}" has no command configured.`);
+    return { ...agent, command };
+  }
+  const provider = agent.provider.trim();
+  const baseUrl = agent.baseUrl.trim();
+  const apiKey = agent.apiKey.trim();
+  if (!provider) throw new Error(`Agent "${agent.id}" has no provider configured.`);
+  if (!baseUrl) throw new Error(`Agent "${agent.id}" has no baseUrl configured.`);
+  if (!apiKey) throw new Error(`Agent "${agent.id}" has no apiKey configured.`);
+  return { ...agent, provider, baseUrl, apiKey };
+}
+function buildAutomationMcpServers(mcpIds) {
+  const settings = storageOps.getSettings();
+  const servers = [];
+  for (const id of mcpIds) {
+    const config = settings.mcpServers?.find((s) => s.id === id);
+    if (!config) continue;
+    if (config.type === "stdio") {
+      servers.push({
+        name: id,
+        command: config.command,
+        args: config.args,
+        env: Object.entries(config.env).map(([k, v]) => ({ name: k, value: v }))
+      });
+    } else if (config.type === "http") {
+      servers.push({
+        type: "http",
+        name: id,
+        url: config.url,
+        headers: Object.entries(config.headers).map(([k, v]) => ({ name: k, value: v }))
+      });
+    }
+  }
+  return servers;
+}
+async function setupSkillsServer(taskDir) {
+  const socketPath = join8(TEMP_DIR, `auto-${randomUUID4()}.socket`);
+  const server = await startSocketServer(socketPath);
+  server.registry("skills/catalog", async () => {
+    return getSkillsCatalog({ projectRoot: taskDir }).map(({ id, name, description }) => ({ id, name, description }));
+  });
+  server.registry("skills/detail", async (payload) => {
+    const { id } = payload;
+    const catalog = getSkillsCatalog({ projectRoot: taskDir });
+    const skill = catalog.find((s) => s.id === id);
+    if (!skill) return { error: `Skill '${id}' not found.` };
+    const skillDir = getSkillSystemPathFromId(skill.id, { projectRoot: taskDir });
+    if (!skillDir) return { error: `Failed to read skill '${id}'` };
+    let body = "";
+    try {
+      const text = fs2.readFileSync(join8(skillDir, SKILL_FILENAME), "utf8");
+      body = parseSkillFrontmatter(text).body;
+    } catch {
+      return { error: `Failed to read skill '${id}'` };
+    }
+    let supportingFiles = [];
+    try {
+      supportingFiles = listSkillFiles(skill.id, { projectRoot: taskDir });
+    } catch {
+    }
+    return { id: skill.id, name: skill.name, description: skill.description, instructions: body, root_path: skillDir, supporting_files: supportingFiles };
+  });
+  const catalogData = getSkillsCatalog({ projectRoot: taskDir }).map(({ id, name, description }) => ({ id, name, description }));
+  const catalogFile = join8(TEMP_DIR, `auto-catalog-${randomUUID4()}.json`);
+  fs2.writeFileSync(catalogFile, JSON.stringify(catalogData), "utf8");
+  const mcpServer = {
+    name: "skills",
+    command: process.execPath,
+    args: [
+      join8(__dirname2, "../scripts/mcp-skills/server.mjs"),
+      "--project-dir",
+      taskDir,
+      "--socket-path",
+      socketPath,
+      "--catalog",
+      catalogFile
+    ],
+    env: [{ name: "ELECTRON_RUN_AS_NODE", value: "1" }]
+  };
+  return { server, mcpServer };
+}
+async function executeTask(scheduleId) {
+  if (runningTasks.has(scheduleId)) {
+    throw new Error("Schedule task is already running");
+  }
+  const schedule = store.getSchedule(scheduleId);
+  if (!schedule) throw new Error("Schedule not found");
+  runningTasks.add(scheduleId);
+  const taskId = String(Date.now());
+  const startedAt = Date.now();
+  const task = { id: taskId, scheduleId, startedAt, completedAt: null, status: "running" };
+  store.saveTask(scheduleId, task);
+  sendEvent?.("task-update", { scheduleId, task });
+  const notifications = [];
+  try {
+    const agentInfo = resolveAgentInfo(schedule.agentId);
+    const taskDir = store.taskDir(scheduleId, taskId);
+    const bridge = new ACPBridge(schedule.agentId, {
+      agentInfo,
+      onSessionUpdate: (notification) => {
+        notifications.push({
+          ...notification,
+          update: {
+            ...notification.update,
+            _meta: { ...notification.update?._meta, fello: { receivedAt: Date.now(), displayId: `auto-${notifications.length}` } }
+          }
+        });
+      },
+      onPermissionRequest: async (req) => {
+        const opt = req.options.find((o) => o.kind === "allow_always") ?? req.options.find((o) => o.kind === "allow_once") ?? req.options[0];
+        return { outcome: { outcome: "selected", optionId: opt?.optionId ?? "allow" } };
+      },
+      onAgentTerminalOutput: () => {
+      }
+    });
+    await bridge.connect();
+    const mcpServers = buildAutomationMcpServers(schedule.mcpServers ?? []);
+    let skillsServer = null;
+    const effectiveFeatures = schedule.features ?? [];
+    if (effectiveFeatures.includes("skills")) {
+      const skills = await setupSkillsServer(taskDir);
+      skillsServer = skills.server;
+      mcpServers.unshift(skills.mcpServer);
+    }
+    const { sessionId } = await bridge.newSession({ cwd: taskDir, mcpServers });
+    const promptContent = [{ type: "text", text: schedule.prompt }];
+    await bridge.sendPrompt({ sessionId, prompt: promptContent });
+    const messages = reduceNotificationsToMessages(notifications);
+    store.writeTaskFile(scheduleId, taskId, "README.md", generateReadme(schedule, messages, startedAt));
+    store.writeTaskFile(scheduleId, taskId, "conversation.json", JSON.stringify(messages, null, 2));
+    await bridge.kill();
+    skillsServer?.stop();
+    schedule.lastRunAt = Date.now();
+    schedule.updatedAt = Date.now();
+    store.saveSchedule(schedule);
+    sendEvent?.("schedules-changed", void 0);
+    task.completedAt = Date.now();
+    task.status = "success";
+    store.saveTask(scheduleId, task);
+    sendEvent?.("task-update", { scheduleId, task });
+    return task;
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    task.completedAt = Date.now();
+    task.status = "error";
+    task.error = errorMessage;
+    store.saveTask(scheduleId, task);
+    sendEvent?.("task-update", { scheduleId, task });
+    console.error(`[Automation] Task failed:`, errorMessage);
+    return task;
+  } finally {
+    runningTasks.delete(scheduleId);
+  }
+}
+function reduceNotificationsToMessages(notifications) {
+  const messages = [];
+  for (const n of notifications) {
+    const update = n.update;
+    if (!update) continue;
+    switch (update.sessionUpdate) {
+      case "user_message_chunk": {
+        const content = update.content;
+        if (!content || content.type !== "text") break;
+        const last = messages[messages.length - 1];
+        if (last && last.role === "user") {
+          last.text += content.text ?? "";
+        } else {
+          messages.push({ role: "user", text: content.text ?? "" });
+        }
+        break;
+      }
+      case "agent_message_chunk": {
+        const content = update.content;
+        if (!content || content.type !== "text") break;
+        const last = messages[messages.length - 1];
+        if (last && last.role === "assistant") {
+          last.text += content.text ?? "";
+        } else {
+          messages.push({ role: "assistant", text: content.text ?? "" });
+        }
+        break;
+      }
+      case "agent_thought_chunk": {
+        const content = update.content;
+        if (!content || content.type !== "text") break;
+        const last = messages[messages.length - 1];
+        if (last && last.role === "thought") {
+          last.text += content.text ?? "";
+        } else {
+          messages.push({ role: "thought", text: content.text ?? "" });
+        }
+        break;
+      }
+      case "tool_call":
+      case "tool_call_update": {
+        const title = update.title ?? "";
+        const content = update.content;
+        let text = "";
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text") text += block.text ?? "";
+          }
+        }
+        messages.push({ role: "tool_call", text, toolTitle: title });
+        break;
+      }
+    }
+  }
+  return messages;
+}
+function generateReadme(schedule, messages, startedAt) {
+  const lines = [];
+  lines.push(`# ${schedule.name}`);
+  lines.push(`> Run at ${new Date(startedAt).toLocaleString()}`);
+  lines.push("");
+  for (const msg of messages) {
+    if (msg.role === "user" || msg.role === "assistant") {
+      const text = msg.text.trim();
+      if (text) lines.push(text + "\n");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/backend/automation/scheduler.ts
+var scheduledCrons = /* @__PURE__ */ new Map();
+function getNextRun(schedule) {
+  const job = scheduledCrons.get(schedule.id);
+  if (!job) return null;
+  try {
+    return job.nextDate().toMillis();
+  } catch {
+    return null;
+  }
+}
+function scheduleCron(schedule) {
+  unscheduleCron(schedule.id);
+  if (schedule.cron.type !== "cron" || !schedule.cron.expr) {
+    return;
+  }
+  try {
+    const cronJob = new CronJob(
+      schedule.cron.expr,
+      async () => {
+        if (runningTasks.has(schedule.id)) {
+          console.log(`[Automation] "${schedule.name}" already running, skipping`);
+          return;
+        }
+        await executeTask(schedule.id);
+      },
+      null,
+      false
+    );
+    scheduledCrons.set(schedule.id, cronJob);
+    cronJob.start();
+    const next = getNextRun(schedule);
+    console.log(
+      `[Automation] Scheduled "${schedule.name}" (${schedule.cron.expr}) next: ${next ? new Date(next).toLocaleString() : "?"}`
+    );
+  } catch (err) {
+    console.error(`[Automation] Failed to schedule "${schedule.name}":`, err);
+  }
+}
+function unscheduleCron(scheduleId) {
+  const existing = scheduledCrons.get(scheduleId);
+  if (existing) {
+    existing.stop();
+    scheduledCrons.delete(scheduleId);
+  }
+}
+function restoreActiveSchedules() {
+  const schedules = store.listSchedules();
+  for (const s of schedules) {
+    if (s.cron.type === "cron" && s.cron.expr) {
+      scheduleCron(s);
+    }
+  }
+  console.log(`[Automation] Restored ${scheduledCrons.size} active schedule(s)`);
+}
+function stopAllCrons() {
+  for (const job of scheduledCrons.values()) {
+    job.stop();
+  }
+  scheduledCrons.clear();
+  console.log("[Automation] All crons stopped");
+}
+var runningTasks = /* @__PURE__ */ new Set();
+
+// src/backend/watcher.ts
+import watcher from "@parcel/watcher";
+import { relative as relative4 } from "path";
+function isFileWatcherEnabled() {
+  return storageOps.getSettings().fileWatcher?.enabled ?? true;
+}
+var subscriptions = /* @__PURE__ */ new Map();
+var MAX_BATCH_CHANGES = 1e3;
+var IGNORE = [
+  "**/.git/**",
+  "**/.svn/**",
+  "**/.hg/**",
+  "**/node_modules/**",
+  "**/bower_components/**",
+  "**/.cache/**",
+  "**/venv/**",
+  "**/.venv/**",
+  "**/vendor/**",
+  "**/__pycache__/**"
+];
+var sendEvent2 = () => false;
+function initWatcher(emitter) {
+  sendEvent2 = emitter;
+  void syncWatchers();
+}
+async function syncWatchers() {
+  const enabled = isFileWatcherEnabled();
+  const projects = storageOps.listProjects();
+  const currentProjects = new Map(projects.map((p) => [p.id, p]));
+  if (!enabled) {
+    for (const [projectId, subscription] of subscriptions.entries()) {
+      await subscription.unsubscribe();
+      subscriptions.delete(projectId);
+    }
+    return;
+  }
+  for (const [projectId, subscription] of subscriptions.entries()) {
+    if (!currentProjects.has(projectId)) {
+      await subscription.unsubscribe();
+      subscriptions.delete(projectId);
+    }
+  }
+  for (const [projectId, project] of currentProjects) {
+    if (!subscriptions.has(projectId)) {
+      await createWatcher(projectId, project.cwd);
+    }
+  }
+}
+async function createWatcher(projectId, cwd) {
+  const changes = /* @__PURE__ */ new Set();
+  let overflowed = false;
+  let timeout = null;
+  const flush = () => {
+    if (changes.size > 0) {
+      sendEvent2("fs-changed", { projectId, changes: Array.from(changes) });
+      changes.clear();
+      overflowed = false;
+    }
+  };
+  const onChange = (path2) => {
+    if (!overflowed) {
+      if (changes.size < MAX_BATCH_CHANGES) {
+        changes.add(path2);
+      } else {
+        overflowed = true;
+        changes.clear();
+        changes.add(".");
+      }
+    }
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(flush, 500);
+  };
+  try {
+    const subscription = await watcher.subscribe(
+      cwd,
+      (err, events) => {
+        if (err) {
+          console.error(`[Watcher] Error for ${projectId} (${cwd}):`, err);
+          return;
+        }
+        for (const event of events) {
+          onChange(toPosixPath(relative4(cwd, event.path)));
+        }
+      },
+      { ignore: IGNORE }
+    );
+    subscriptions.set(projectId, subscription);
+  } catch (err) {
+    console.error(`[Watcher] Failed to subscribe for ${projectId} (${cwd}):`, err);
+  }
+}
+
 // src/backend/i18n.ts
 import i18next from "i18next";
 
@@ -4868,7 +5332,7 @@ function setLanguage(lang) {
 // src/backend/backend.ts
 var require2 = createRequire(import.meta.url);
 var execFileAsync = promisify(execFile);
-var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
 function buildMcpServersConfig(sessionMcpIds, options) {
   const { project, socketPath, features = ALL_FEATURES } = options;
   const servers = [];
@@ -4876,13 +5340,13 @@ function buildMcpServersConfig(sessionMcpIds, options) {
     const skillCatalog = getSkillsCatalog({
       projectRoot: project.cwd
     }).map((skill) => omit(skill, ["scope", "level"]));
-    const skillCatalogFilename = join7(TEMP_DIR, `project-${project.id}-${randomUUID4()}.json`);
-    fs2.writeFileSync(skillCatalogFilename, JSON.stringify(skillCatalog), "utf8");
+    const skillCatalogFilename = join9(TEMP_DIR, `project-${project.id}-${randomUUID5()}.json`);
+    fs3.writeFileSync(skillCatalogFilename, JSON.stringify(skillCatalog), "utf8");
     servers.push({
       name: "skills",
       command: process.execPath,
       args: [
-        join7(__dirname2, "../scripts/mcp-skills/server.mjs"),
+        join9(__dirname3, "../scripts/mcp-skills/server.mjs"),
         "--project-dir",
         project.cwd,
         "--socket-path",
@@ -4903,7 +5367,7 @@ function buildMcpServersConfig(sessionMcpIds, options) {
       name: "ask-user",
       command: process.execPath,
       args: [
-        join7(__dirname2, "../scripts/mcp-ask-user/server.mjs"),
+        join9(__dirname3, "../scripts/mcp-ask-user/server.mjs"),
         "--project-dir",
         project.cwd,
         "--socket-path",
@@ -4953,7 +5417,7 @@ function generateSessionSocketPath(key) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\fello-${key}-${timestamp}`;
   }
-  return join7(SOCKETS_DIR, `${key}-${timestamp}.socket`);
+  return join9(SOCKETS_DIR, `${key}-${timestamp}.socket`);
 }
 async function createSessionSocketServer(sessionId, options) {
   const existing = sessionSocketServers.get(sessionId);
@@ -4997,10 +5461,10 @@ async function createSessionSocketServer(sessionId, options) {
     if (!skillDir) {
       return { error: `Failed to Read skill '${id}'` };
     }
-    const skillFile = join7(skillDir, SKILL_FILENAME);
+    const skillFile = join9(skillDir, SKILL_FILENAME);
     let body = "";
     try {
-      const text = fs2.readFileSync(skillFile, "utf8");
+      const text = fs3.readFileSync(skillFile, "utf8");
       const parsed = parseSkillFrontmatter(text);
       body = parsed.body;
     } catch {
@@ -5055,9 +5519,9 @@ function formatAskUserForWeChat(request) {
 }
 async function askUser(options) {
   const { sessionId } = options;
-  const askUserId = randomUUID4();
+  const askUserId = randomUUID5();
   const request = { ...options, askUserId };
-  sendEvent2("ask-user-request", request);
+  sendEvent3("ask-user-request", request);
   if (ilinkBridge?.isConnected && sessionId === ilinkActiveSessionId) {
     const userId = ilinkBridge.userId;
     if (userId) {
@@ -5076,7 +5540,7 @@ async function askUser(options) {
         pendingAskUserRequests.delete(askUserId);
         const response = { value: null, reason: "timeout" };
         resolve4(response);
-        sendEvent2("ask-user-response", {
+        sendEvent3("ask-user-response", {
           sessionId,
           askUserId,
           value: null,
@@ -5097,7 +5561,7 @@ function getILinkBridge() {
   if (!ilinkBridge) {
     ilinkBridge = new ILinkBridge({
       onStatusChange: (status) => {
-        sendEvent2("ilink-status-changed", { status });
+        sendEvent3("ilink-status-changed", { status });
         broadcastWebUIEvent("ilink-status-changed", { status });
       },
       onMessage: async (msg) => {
@@ -5182,7 +5646,7 @@ function getILinkBridge() {
               ilinkReplyBuffer = "";
               writeActiveSessionId(entry.sessionId).catch(() => {
               });
-              sendEvent2("ilink-active-session-changed", { sessionId: entry.sessionId });
+              sendEvent3("ilink-active-session-changed", { sessionId: entry.sessionId });
               if (msg.from_user_id) {
                 ilinkBridge?.sendTextReply(
                   msg.from_user_id,
@@ -5246,7 +5710,7 @@ function getILinkBridge() {
                 ilinkReplyBuffer = "";
                 writeActiveSessionId(newSessionId).catch(() => {
                 });
-                sendEvent2("ilink-active-session-changed", { sessionId: newSessionId });
+                sendEvent3("ilink-active-session-changed", { sessionId: newSessionId });
                 if (msg.from_user_id) {
                   ilinkBridge?.sendTextReply(
                     msg.from_user_id,
@@ -5555,7 +6019,7 @@ var terminals = /* @__PURE__ */ new Map();
 var clientTerminals = /* @__PURE__ */ new Map();
 var terminalCounter = 0;
 var isNodePtyHelperPrepared = false;
-var sendEvent2 = () => false;
+var sendEvent3 = () => false;
 function broadcastAndSaveSessionUpdate(sessionId, notification) {
   const enrichedNotification = {
     ...notification,
@@ -5565,7 +6029,7 @@ function broadcastAndSaveSessionUpdate(sessionId, notification) {
         ...notification.update?._meta,
         fello: {
           receivedAt: Date.now(),
-          displayId: randomUUID4()
+          displayId: randomUUID5()
         }
       }
     }
@@ -5617,7 +6081,7 @@ function broadcastAndSaveSessionUpdate(sessionId, notification) {
   } else {
     storageOps.appendSessionMessage(sessionId, enrichedNotification);
   }
-  sendEvent2("session-update", { sessionId, notification: enrichedNotification });
+  sendEvent3("session-update", { sessionId, notification: enrichedNotification });
 }
 function markProjectFsDirty(projectId) {
   const nextVersion = (projectFsVersions.get(projectId) ?? 0) + 1;
@@ -5639,7 +6103,7 @@ async function buildSearchIndex(cwd) {
     fileScene.add(dir);
     const entries = await readdir(dir).catch(() => []);
     for (const name of entries) {
-      const full = join7(dir, name);
+      const full = join9(dir, name);
       const s = await stat3(full).catch(() => null);
       if (!s) continue;
       if (isIgnorePath(full, cwd)) continue;
@@ -5654,7 +6118,7 @@ async function buildSearchIndex(cwd) {
   return allFiles;
 }
 function initBackend(emitter) {
-  sendEvent2 = (channel, payload) => {
+  sendEvent3 = (channel, payload) => {
     if (channel === "fs-changed") {
       markProjectFsDirty(payload.projectId);
     }
@@ -5662,20 +6126,22 @@ function initBackend(emitter) {
     const sentNative = emitter(channel, payload);
     return sentWebUI || sentNative;
   };
-  initWatcher(sendEvent2);
+  initWatcher(sendEvent3);
+  initRunner(sendEvent3);
+  restoreActiveSchedules();
   getILinkBridge().tryRestore().then(async (restored) => {
     if (restored) {
       const savedId = await readActiveSessionId();
       if (savedId && storageOps.getSession(savedId)) {
         ilinkActiveSessionId = savedId;
-        sendEvent2("ilink-active-session-changed", { sessionId: savedId });
+        sendEvent3("ilink-active-session-changed", { sessionId: savedId });
       }
     }
   }).catch((err) => {
     console.warn("[iLink] Failed to restore session:", err);
   });
 }
-function resolveAgentInfo(agentId) {
+function resolveAgentInfo2(agentId) {
   const settings = storageOps.getSettings();
   const agent = settings.agents.find((a) => a.id === agentId);
   if (!agent) {
@@ -5708,7 +6174,7 @@ async function ensureBridge(agentId) {
     }
     await pooledBridge.kill();
   }
-  const agentInfo = resolveAgentInfo(agentId);
+  const agentInfo = resolveAgentInfo2(agentId);
   const nextBridge = new ACPBridge(agentId, {
     agentInfo,
     onSessionUpdate: (notification) => {
@@ -5718,7 +6184,7 @@ async function ensureBridge(agentId) {
         if (notification.update.title) {
           storageOps.updateSession(sessionId, { title: notification.update.title });
           const updated = storageOps.getSession(sessionId);
-          if (updated) sendEvent2("session-changed", { session: updated });
+          if (updated) sendEvent3("session-changed", { session: updated });
         }
       }
       if (sessionUpdate === "current_mode_update") {
@@ -5727,7 +6193,7 @@ async function ensureBridge(agentId) {
           session.modes.currentModeId = notification.update.currentModeId ?? null;
           storageOps.updateSession(sessionId, { modes: session.modes });
           const updated = storageOps.getSession(sessionId);
-          if (updated) sendEvent2("session-changed", { session: updated });
+          if (updated) sendEvent3("session-changed", { session: updated });
         }
       }
       if (restoringSessions.has(sessionId) && sessionUpdate !== "available_commands_update" && sessionUpdate !== "usage_update") {
@@ -5790,7 +6256,7 @@ async function ensureBridge(agentId) {
       } catch (err) {
         console.error("write terminal output error: ", { sessionId, terminalId, err });
       }
-      sendEvent2("agent-terminal-output", { sessionId, terminalId, data });
+      sendEvent3("agent-terminal-output", { sessionId, terminalId, data });
     }
   });
   let newConnectPromise;
@@ -5805,6 +6271,7 @@ async function ensureBridge(agentId) {
   return newConnectPromise;
 }
 async function clearBackend() {
+  stopAllCrons();
   for (const ss of sessionSocketServers.values()) {
     ss.stop();
   }
@@ -5822,11 +6289,11 @@ async function clearBackend() {
   clientTerminals.clear();
   await Promise.all(killPromises);
   for (const file of await readdir(TEMP_DIR)) {
-    await rm2(join7(TEMP_DIR, file), { recursive: true, force: true });
+    await rm2(join9(TEMP_DIR, file), { recursive: true, force: true });
   }
 }
 async function resolveTerminalCwd(preferredCwd) {
-  const candidates = [preferredCwd, process.cwd(), homedir3()].map((value) => value.trim()).filter((value, index, array) => value.length > 0 && array.indexOf(value) === index);
+  const candidates = [preferredCwd, process.cwd(), homedir4()].map((value) => value.trim()).filter((value, index, array) => value.length > 0 && array.indexOf(value) === index);
   for (const candidate of candidates) {
     const info = await stat3(candidate).catch(() => null);
     if (info?.isDirectory()) return candidate;
@@ -5847,8 +6314,8 @@ async function ensureNodePtySpawnHelperExecutable() {
   if (process.platform === "win32") return;
   if (isNodePtyHelperPrepared) return;
   const packageJsonPath = require2.resolve("node-pty/package.json");
-  const packageDir = dirname4(packageJsonPath);
-  const helperPath = join7(
+  const packageDir = dirname6(packageJsonPath);
+  const helperPath = join9(
     packageDir,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -5911,14 +6378,14 @@ async function createTerminalProcess(cwd, initialSize) {
   const terminalId = createHash3("sha1").update(terminalSeed).digest("hex").slice(0, 12);
   terminals.set(terminalId, child);
   child.onData((data) => {
-    sendEvent2("terminal-output", { terminalId, data });
+    sendEvent3("terminal-output", { terminalId, data });
   });
   child.onExit((exitCode) => {
     terminals.delete(terminalId);
     for (const set of clientTerminals.values()) {
       set.delete(terminalId);
     }
-    sendEvent2("terminal-exit", { terminalId, exitCode });
+    sendEvent3("terminal-exit", { terminalId, exitCode });
   });
   return terminalId;
 }
@@ -5996,7 +6463,7 @@ var backendHandlers = {
     if (!skillDir) {
       throw new Error(`Failed to read skill: ${skillId}`);
     }
-    return join7(skillDir, SKILL_FILENAME);
+    return join9(skillDir, SKILL_FILENAME);
   },
   async uninstallSkill({ skillId, projectId }) {
     const projectRoot = projectId ? storageOps.getProject(projectId)?.cwd : void 0;
@@ -6027,13 +6494,13 @@ var backendHandlers = {
   async startWebUIServer({ port: port2, token: token2 }) {
     const { url } = await startWebUI({ port: port2, token: token2 });
     const status = { enabled: true, url };
-    sendEvent2("webui-status-changed", { status });
+    sendEvent3("webui-status-changed", { status });
     return status;
   },
   async stopWebUIServer() {
     stopWebUI();
     const status = { enabled: false, url: null };
-    sendEvent2("webui-status-changed", { status });
+    sendEvent3("webui-status-changed", { status });
     return status;
   },
   async getSettings() {
@@ -6070,12 +6537,12 @@ var backendHandlers = {
       projectFsVersions.set(ProjectInfo.id, 0);
     }
     await syncWatchers();
-    sendEvent2("projects-changed", void 0);
+    sendEvent3("projects-changed", void 0);
     return ProjectInfo;
   },
   async renameProject({ projectId, title }) {
     storageOps.updateProjectTitle(projectId, title);
-    sendEvent2("projects-changed", void 0);
+    sendEvent3("projects-changed", void 0);
   },
   async deleteProject(projectId) {
     const projectSessions = storageOps.listSessions().filter((session) => session.projectId === projectId);
@@ -6109,14 +6576,14 @@ var backendHandlers = {
     }
     clearProjectSearchState(projectId);
     await syncWatchers();
-    sendEvent2("projects-changed", void 0);
-    sendEvent2("sessions-changed", void 0);
+    sendEvent3("projects-changed", void 0);
+    sendEvent3("sessions-changed", void 0);
   },
   async newSession({ projectId, agentId, mcpServers, permissionMode, features }) {
     const project = storageOps.getProject(projectId);
     if (!project) throw new Error("Project does not exist");
     const b = await ensureBridge(agentId);
-    const socketPath = generateSessionSocketPath(randomUUID4());
+    const socketPath = generateSessionSocketPath(randomUUID5());
     const sessionMcpIds = mcpServers ?? (storageOps.getSettings().mcpServers || []).filter((s) => !s.disabled).map((s) => s.id);
     const effectiveFeatures = features ?? ALL_FEATURES;
     const activeMcpServers = buildMcpServersConfig(sessionMcpIds, {
@@ -6141,7 +6608,7 @@ var backendHandlers = {
       initializeInfo: b.initializeInfo
     });
     await createSessionSocketServer(sessionInfo.id, { socketPath, project });
-    sendEvent2("sessions-changed", void 0);
+    sendEvent3("sessions-changed", void 0);
     return {
       sessionId: sessionInfo.id,
       initializeInfo: b.initializeInfo,
@@ -6166,10 +6633,10 @@ var backendHandlers = {
     if (session.isStreaming) {
       storageOps.updateSession(sessionId, { isStreaming: false });
       session.isStreaming = false;
-      sendEvent2("session-changed", { session });
+      sendEvent3("session-changed", { session });
     }
     const existingSocketServer = sessionSocketServers.get(session.id);
-    const socketPath = existingSocketServer ? existingSocketServer.socketPath : generateSessionSocketPath(randomUUID4());
+    const socketPath = existingSocketServer ? existingSocketServer.socketPath : generateSessionSocketPath(randomUUID5());
     const activeMcpServers = buildMcpServersConfig(session.mcpServers, {
       project,
       socketPath,
@@ -6230,7 +6697,7 @@ var backendHandlers = {
     }
     const freshSession = storageOps.getSession(session.id);
     if (freshSession) {
-      sendEvent2("session-changed", { session: freshSession });
+      sendEvent3("session-changed", { session: freshSession });
     }
     return {
       sessionId: session.id,
@@ -6293,7 +6760,7 @@ var backendHandlers = {
     const b = await ensureBridge(session.agentId);
     if (!b.isSessionLoaded(session.resumeId)) {
       console.log(`[Fello] Session ${session.resumeId} not loaded in Agent, lazy loading...`);
-      const socketPath = generateSessionSocketPath(randomUUID4());
+      const socketPath = generateSessionSocketPath(randomUUID5());
       const activeMcpServers = buildMcpServersConfig(session.mcpServers, {
         project,
         socketPath,
@@ -6308,8 +6775,8 @@ var backendHandlers = {
     }
     storageOps.updateSession(sessionId, { isStreaming: true });
     const updated = storageOps.getSession(sessionId);
-    if (updated) sendEvent2("session-changed", { session: updated });
-    sendEvent2("prompt-start", { sessionId });
+    if (updated) sendEvent3("session-changed", { session: updated });
+    sendEvent3("prompt-start", { sessionId });
     if (ilinkBridge?.isConnected && sessionId === ilinkActiveSessionId) {
       const userId = ilinkBridge.userId;
       if (userId) {
@@ -6339,14 +6806,14 @@ var backendHandlers = {
       promptError = err instanceof Error ? err.message : String(err);
       throw err;
     } finally {
-      sendEvent2("prompt-end", {
+      sendEvent3("prompt-end", {
         sessionId,
         stopReason: promptResponse?.stopReason,
         error: promptError
       });
       storageOps.updateSession(sessionId, { isStreaming: false });
       const updated2 = storageOps.getSession(sessionId);
-      if (updated2) sendEvent2("session-changed", { session: updated2 });
+      if (updated2) sendEvent3("session-changed", { session: updated2 });
       if (ilinkBridge?.isConnected && sessionId === ilinkActiveSessionId) {
         const userId = ilinkBridge.userId;
         if (userId) {
@@ -6415,7 +6882,7 @@ var backendHandlers = {
       clearTimeout(pending.timeoutId);
       pending.resolve({ value, reason: reason ?? null });
       pendingAskUserRequests.delete(askUserId);
-      sendEvent2("ask-user-response", {
+      sendEvent3("ask-user-response", {
         sessionId,
         askUserId,
         value,
@@ -6428,7 +6895,7 @@ var backendHandlers = {
   async updateSession({ sessionId, ...updates }) {
     storageOps.updateSession(sessionId, updates);
     const session = storageOps.getSession(sessionId);
-    if (session) sendEvent2("session-changed", { session });
+    if (session) sendEvent3("session-changed", { session });
   },
   async changeWorkDir() {
     return { ok: false, cwd: null };
@@ -6461,7 +6928,7 @@ var backendHandlers = {
       } catch (error) {
         console.warn("[iLink] Failed to clear persisted active session:", error);
       }
-      sendEvent2("ilink-active-session-changed", { sessionId: null });
+      sendEvent3("ilink-active-session-changed", { sessionId: null });
     }
     if (session) {
       try {
@@ -6476,7 +6943,7 @@ var backendHandlers = {
         );
       }
     }
-    sendEvent2("sessions-changed", void 0);
+    sendEvent3("sessions-changed", void 0);
   },
   async getSystemFilePath({ projectId, path: inputPath, isAbsolute: isAbsolute4 }) {
     const project = storageOps.getProject(projectId);
@@ -6491,14 +6958,14 @@ var backendHandlers = {
     if (!project) throw new Error("Project not found");
     const cwd = destDir || project.cwd;
     const fileName = basename3(sourcePath);
-    let destPath = join7(cwd, fileName);
+    let destPath = join9(cwd, fileName);
     let counter = 1;
     while (true) {
       const info = await stat3(destPath).catch(() => null);
       if (!info) break;
       const ext = extname2(fileName);
       const name = basename3(fileName, ext);
-      destPath = join7(cwd, `${name}(${counter})${ext}`);
+      destPath = join9(cwd, `${name}(${counter})${ext}`);
       counter++;
     }
     await copyFile(sourcePath, destPath);
@@ -6569,7 +7036,7 @@ var backendHandlers = {
       session.models.currentModelId = modelId;
       storageOps.updateSession(session.id, { models: session.models });
       const updated = storageOps.getSession(session.id);
-      if (updated) sendEvent2("session-changed", { session: updated });
+      if (updated) sendEvent3("session-changed", { session: updated });
     }
   },
   async getModes({ sessionId }) {
@@ -6591,7 +7058,7 @@ var backendHandlers = {
       session.modes.currentModeId = modeId;
       storageOps.updateSession(session.id, { modes: session.modes });
       const updated = storageOps.getSession(session.id);
-      if (updated) sendEvent2("session-changed", { session: updated });
+      if (updated) sendEvent3("session-changed", { session: updated });
     }
   },
   async searchFiles({ projectId, query }) {
@@ -6603,7 +7070,7 @@ var backendHandlers = {
       const entries = await readdir(cwd).catch(() => []);
       const results = [];
       for (const name of entries) {
-        const full = join7(cwd, name);
+        const full = join9(cwd, name);
         if (isIgnorePath(full, cwd)) continue;
         if (fileScene.has(full)) continue;
         fileScene.add(full);
@@ -6645,7 +7112,7 @@ var backendHandlers = {
     const entries = await readdir(startPath).catch(() => []);
     const results = [];
     for (const name of entries) {
-      const full = join7(startPath, name);
+      const full = join9(startPath, name);
       const s = await stat3(full).catch(() => null);
       if (!s) continue;
       if (isIgnorePath(full, cwd)) continue;
@@ -6669,7 +7136,7 @@ var backendHandlers = {
     if (isFolder) {
       await mkdir2(targetPath, { recursive: true });
     } else {
-      await mkdir2(dirname4(targetPath), { recursive: true });
+      await mkdir2(dirname6(targetPath), { recursive: true });
       await writeFile3(targetPath, "");
     }
     markProjectFsDirty(projectId);
@@ -6740,7 +7207,7 @@ var backendHandlers = {
     const ext = extname2(fileName);
     const base = basename3(fileName, ext);
     let counter = 0;
-    let currentDest = join7(destDir, fileName);
+    let currentDest = join9(destDir, fileName);
     while (true) {
       const existing = await stat3(currentDest).catch(() => null);
       if (!existing) break;
@@ -6748,7 +7215,7 @@ var backendHandlers = {
         throw new Error("Cannot overwrite a folder with a file");
       }
       counter++;
-      currentDest = join7(destDir, `${base}(${counter})${ext}`);
+      currentDest = join9(destDir, `${base}(${counter})${ext}`);
     }
     const buffer = Buffer.from(base64, "base64");
     await mkdir2(destDir, { recursive: true });
@@ -6867,7 +7334,7 @@ var backendHandlers = {
       const project = storageOps.getProject(projectId);
       if (!project) throw new Error("Project not found");
       const targetPath = resolveSafePath(project.cwd, relativePath);
-      const cwd = dirname4(targetPath);
+      const cwd = dirname6(targetPath);
       const relPath = relative5(cwd, targetPath);
       const { stdout } = await execFileAsync("git", ["show", `HEAD:./${relPath}`], {
         cwd,
@@ -6910,14 +7377,14 @@ var backendHandlers = {
     ilinkActiveSessionId = null;
     ilinkReplyBuffer = "";
     await writeActiveSessionId(null);
-    sendEvent2("ilink-active-session-changed", { sessionId: null });
+    sendEvent3("ilink-active-session-changed", { sessionId: null });
   },
   async setActiveIlinkSession({ sessionId }) {
     if (!sessionId) {
       ilinkActiveSessionId = null;
       ilinkReplyBuffer = "";
       await writeActiveSessionId(null);
-      sendEvent2("ilink-active-session-changed", { sessionId: null });
+      sendEvent3("ilink-active-session-changed", { sessionId: null });
       return;
     }
     const session = storageOps.getSession(sessionId);
@@ -6925,7 +7392,7 @@ var backendHandlers = {
     ilinkActiveSessionId = sessionId;
     ilinkReplyBuffer = "";
     await writeActiveSessionId(sessionId);
-    sendEvent2("ilink-active-session-changed", { sessionId });
+    sendEvent3("ilink-active-session-changed", { sessionId });
   },
   async getActiveIlinkSession() {
     if (ilinkActiveSessionId) {
@@ -6940,11 +7407,80 @@ var backendHandlers = {
     } catch {
     }
     return { sessionId: null };
+  },
+  // ── Automation Handlers ───────────────────────────────────────────
+  async listSchedules() {
+    return store.listSchedules().map((s) => ({ ...s, nextRunAt: getNextRun(s) }));
+  },
+  async getServerTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  },
+  async createSchedule(params) {
+    const scheduleId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const now = Date.now();
+    const schedule = {
+      id: scheduleId,
+      name: params.name,
+      agentId: params.agentId,
+      prompt: params.prompt,
+      cron: { type: params.cron.type, expr: params.cron.expr },
+      createdAt: now,
+      updatedAt: now,
+      lastRunAt: null,
+      features: (params.features ?? []).filter((f) => f !== "ask_user"),
+      mcpServers: params.mcpServers ?? []
+    };
+    store.saveSchedule(schedule);
+    if (schedule.cron.type === "cron" && schedule.cron.expr) {
+      scheduleCron(schedule);
+    }
+    sendEvent3("schedules-changed", void 0);
+    return schedule;
+  },
+  async updateSchedule({ scheduleId, updates }) {
+    const schedule = store.getSchedule(scheduleId);
+    if (!schedule) throw new Error("Schedule not found");
+    Object.assign(schedule, updates);
+    schedule.updatedAt = Date.now();
+    store.saveSchedule(schedule);
+    if (schedule.cron.type === "cron" && schedule.cron.expr) {
+      scheduleCron(schedule);
+    } else {
+      unscheduleCron(scheduleId);
+    }
+    sendEvent3("schedules-changed", void 0);
+    return schedule;
+  },
+  async deleteSchedule({ scheduleId }) {
+    unscheduleCron(scheduleId);
+    store.deleteSchedule(scheduleId);
+    sendEvent3("schedules-changed", void 0);
+  },
+  async triggerSchedule({ scheduleId }) {
+    return executeTask(scheduleId);
+  },
+  async getTasks({ scheduleId }) {
+    return store.listTasks(scheduleId);
+  },
+  async getTaskFiles({ scheduleId, taskId }) {
+    return store.listTaskFiles(scheduleId, taskId);
+  },
+  async readTaskFile({ scheduleId, taskId, filePath }) {
+    return store.readTaskFile(scheduleId, taskId, filePath);
+  },
+  async getTaskFileSystemPath({ scheduleId, taskId, filePath }) {
+    const base = store.taskDir(scheduleId, taskId);
+    const fullPath = join9(base, filePath);
+    if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
+    return fullPath;
+  },
+  async deleteTask({ scheduleId, taskId }) {
+    store.deleteTask(scheduleId, taskId);
   }
 };
 
 // package.json
-var version = "0.1.28";
+var version = "0.1.29";
 
 // src/server/main.ts
 var port;