@zythum02/fello-server 0.1.30 → 0.1.32

package/out/server/main.js

@@ -3319,7 +3319,7 @@ import { createServer } from "http";
 import { WebSocketServer } from "ws";
 import { randomBytes as randomBytes2 } from "crypto";
 import { networkInterfaces } from "os";
-import { dirname, join as join4 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 import { fileURLToPath } from "url";
 import { readFile as readFile4, stat as stat2 } from "fs/promises";
 
@@ -3389,6 +3389,146 @@ async function serveProjectFile(projectCwd, relativePath) {
   }
 }
 
+// src/backend/automation/store.ts
+import { join as join4, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import {
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  rmSync as rmSync3,
+  existsSync as existsSync2,
+  statSync as statSync2
+} from "fs";
+var AUTOMATIONS_DIR = join4(homedir2(), ".fello", "automations");
+mkdirSync3(AUTOMATIONS_DIR, { recursive: true });
+var store = {
+  scheduleDir(scheduleId) {
+    return join4(AUTOMATIONS_DIR, scheduleId);
+  },
+  scheduleConfigPath(scheduleId) {
+    return join4(this.scheduleDir(scheduleId), "schedule.json");
+  },
+  tasksDir(scheduleId) {
+    return join4(this.scheduleDir(scheduleId), "tasks");
+  },
+  taskDir(scheduleId, taskId) {
+    return join4(this.tasksDir(scheduleId), taskId);
+  },
+  taskMetaPath(scheduleId, taskId) {
+    return join4(this.taskDir(scheduleId, taskId), "task.json");
+  },
+  listSchedules() {
+    if (!existsSync2(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 {
+      }
+    }
+    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;
+    }
+  },
+  saveSchedule(schedule) {
+    const dir = this.scheduleDir(schedule.id);
+    mkdirSync3(dir, { recursive: true });
+    mkdirSync3(this.tasksDir(schedule.id), { recursive: true });
+    writeFileSync3(this.scheduleConfigPath(schedule.id), JSON.stringify(schedule, null, 2));
+  },
+  deleteSchedule(scheduleId) {
+    const dir = this.scheduleDir(scheduleId);
+    if (existsSync2(dir)) {
+      rmSync3(dir, { recursive: true, force: true });
+    }
+  },
+  listTasks(scheduleId) {
+    const dir = this.tasksDir(scheduleId);
+    if (!existsSync2(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 {
+      }
+    }
+    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);
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync3(this.taskMetaPath(scheduleId, task.id), JSON.stringify(task, null, 2));
+  },
+  deleteTask(scheduleId, taskId) {
+    const dir = this.taskDir(scheduleId, taskId);
+    if (existsSync2(dir)) {
+      rmSync3(dir, { recursive: true, force: true });
+    }
+  },
+  listTaskFiles(scheduleId, taskId) {
+    const dir = this.taskDir(scheduleId, taskId);
+    if (!existsSync2(dir)) return [];
+    const entries = readdirSync2(dir);
+    return entries.filter((f) => f !== "task.json").map((f) => {
+      const fullPath = join4(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 = join4(dir, entry);
+      const s = statSync2(full);
+      if (s.isDirectory()) {
+        result.push(...this._listDirRecursive(full, join4(prefix, entry)));
+      } else {
+        result.push(join4(prefix, entry));
+      }
+    }
+    return result;
+  },
+  readTaskFile(scheduleId, taskId, filePath, encoding) {
+    const base = this.taskDir(scheduleId, taskId);
+    const fullPath = join4(base, filePath);
+    if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
+    if (!existsSync2(fullPath)) throw new Error("File not found");
+    if (encoding === "base64") return readFileSync3(fullPath).toString("base64");
+    return readFileSync3(fullPath, "utf-8");
+  },
+  writeTaskFile(scheduleId, taskId, filePath, content) {
+    const base = this.taskDir(scheduleId, taskId);
+    const fullPath = join4(base, filePath);
+    if (!fullPath.startsWith(base + "/") && fullPath !== base) throw new Error("Invalid file path");
+    mkdirSync3(dirname(fullPath), { recursive: true });
+    writeFileSync3(fullPath, content);
+  }
+};
+
 // src/backend/utils.ts
 import { relative as relative2, resolve as resolve3, isAbsolute as isAbsolute2 } from "path";
 function toPosixPath(p) {
@@ -3460,7 +3600,7 @@ function extractErrorMessage(error) {
 
 // src/backend/webui.ts
 import * as mimeTypes2 from "mime-types";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 var httpServer = null;
 var wss = null;
 var currentToken = null;
@@ -3573,17 +3713,33 @@ async function startWebUI(options) {
       res.end(result.body);
       return;
     }
+    if (url.pathname.startsWith("/automation/")) {
+      const pathParts = url.pathname.split("/");
+      const scheduleId = pathParts[2] || "";
+      const taskId = pathParts[4] || "";
+      const relativePath = decodeURIComponent(pathParts.slice(5).join("/") || "");
+      if (!scheduleId || pathParts[3] !== "task" || !taskId || !relativePath) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Bad Request");
+        return;
+      }
+      const taskDir = store.taskDir(scheduleId, taskId);
+      const result = await serveProjectFile(taskDir, relativePath);
+      res.writeHead(result.status, { "Content-Type": result.mimeType });
+      res.end(result.body);
+      return;
+    }
     try {
       const isFile = url.pathname !== "/" && !url.pathname.endsWith("/");
       let reqPath = url.pathname;
       if (!isFile) {
         reqPath = "/index.html";
       }
-      const baseDir = join4(__dirname, "../renderer");
-      let filePath = join4(baseDir, reqPath);
+      const baseDir = join5(__dirname, "../renderer");
+      let filePath = join5(baseDir, reqPath);
       let s = await stat2(filePath).catch(() => null);
       if (!s || s.isDirectory()) {
-        filePath = join4(baseDir, "index.html");
+        filePath = join5(baseDir, "index.html");
       }
       const mime = mimeTypes2.lookup(filePath) || "application/octet-stream";
       const content = await readFile4(filePath);
@@ -3689,15 +3845,15 @@ function getWebUIUrl(addressInfo) {
 
 // src/backend/socket-server.ts
 import { createServer as createServer2 } from "http";
-import { dirname as dirname2 } from "path";
-import { mkdirSync as mkdirSync3, existsSync as existsSync2, unlinkSync } from "fs";
+import { dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync4, existsSync as existsSync3, unlinkSync } from "fs";
 function isWindowsPipePath(p) {
   return /^\\\\.\\pipe\\/i.test(p);
 }
 async function startSocketServer(socketPath) {
   if (!isWindowsPipePath(socketPath)) {
-    mkdirSync3(dirname2(socketPath), { recursive: true });
-    if (existsSync2(socketPath)) {
+    mkdirSync4(dirname3(socketPath), { recursive: true });
+    if (existsSync3(socketPath)) {
       unlinkSync(socketPath);
     }
   }
@@ -3750,7 +3906,7 @@ async function startSocketServer(socketPath) {
           server.close();
           server.closeAllConnections?.();
           if (!isWindowsPipePath(socketPath)) {
-            if (existsSync2(socketPath)) {
+            if (existsSync3(socketPath)) {
               try {
                 unlinkSync(socketPath);
               } catch {
@@ -3814,7 +3970,7 @@ var skillDetailSchema = z3.object({
 
 // src/backend/ilink/ilink-bridge.ts
 import { readFile as readFile5, writeFile as writeFile2, mkdir, rm } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/backend/ilink/ilink-crypto.ts
@@ -3990,10 +4146,10 @@ var ILinkClient = class {
 };
 
 // src/backend/ilink/ilink-bridge.ts
-var ILINK_DIR = join5(FELLO_DIR, "ilink");
-var CREDENTIALS_PATH = join5(ILINK_DIR, "credentials.json");
-var CURSOR_PATH = join5(ILINK_DIR, "cursor.json");
-var ACTIVE_SESSION_PATH = join5(ILINK_DIR, "active-session.json");
+var ILINK_DIR = join6(FELLO_DIR, "ilink");
+var CREDENTIALS_PATH = join6(ILINK_DIR, "credentials.json");
+var CURSOR_PATH = join6(ILINK_DIR, "cursor.json");
+var ACTIVE_SESSION_PATH = join6(ILINK_DIR, "active-session.json");
 async function ensureDir() {
   await mkdir(ILINK_DIR, { recursive: true });
 }
@@ -4429,145 +4585,6 @@ var ILinkBridge = class _ILinkBridge {
   }
 };
 
-// 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 {
-      }
-    }
-    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;
-    }
-  },
-  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 });
-    }
-  },
-  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 {
-      }
-    }
-    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 {
-        result.push(join6(prefix, entry));
-      }
-    }
-    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";
 
@@ -7493,8 +7510,8 @@ var backendHandlers = {
   async getTaskFiles({ scheduleId, taskId }) {
     return store.listTaskFiles(scheduleId, taskId);
   },
-  async readTaskFile({ scheduleId, taskId, filePath }) {
-    return store.readTaskFile(scheduleId, taskId, filePath);
+  async readTaskFile({ scheduleId, taskId, filePath, encoding }) {
+    return store.readTaskFile(scheduleId, taskId, filePath, encoding);
   },
   async getTaskFileSystemPath({ scheduleId, taskId, filePath }) {
     const base = store.taskDir(scheduleId, taskId);
@@ -7508,7 +7525,7 @@ var backendHandlers = {
 };
 
 // package.json
-var version = "0.1.30";
+var version = "0.1.32";
 
 // src/server/main.ts
 var port;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zythum02/fello-server",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Fello Server — standalone headless AI agent server",
   "type": "module",
   "bin": {