@surething/cockpit 1.0.175

package/dist/chunk-OER3N6H7.mjs

@@ -0,0 +1,250 @@
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+var HOME_DIR = homedir();
+var COCKPIT_DIR = join(HOME_DIR, ".cockpit");
+var COCKPIT_PROJECTS_DIR = join(COCKPIT_DIR, "projects");
+var GLOBAL_STATE_FILE = join(COCKPIT_DIR, "state.json");
+var PINNED_SESSIONS_FILE = join(COCKPIT_DIR, "pinned-sessions.json");
+var NOTE_FILE = join(COCKPIT_DIR, "note.md");
+var SCHEDULED_TASKS_FILE = join(COCKPIT_DIR, "scheduled-tasks.json");
+var SETTINGS_FILE = join(COCKPIT_DIR, "settings.json");
+var REVIEW_DIR = join(COCKPIT_DIR, "review");
+var REVIEW_SIGNAL_FILE = join(REVIEW_DIR, "_signal");
+var CLAUDE_DIR = join(HOME_DIR, ".claude");
+var CLAUDE_PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+function encodePath(path) {
+  return path.replace(/[/.]/g, "-");
+}
+function getCockpitProjectDir(cwd) {
+  return join(COCKPIT_PROJECTS_DIR, encodePath(cwd));
+}
+function getTerminalHistoryPath(cwd, tabId) {
+  return join(getCockpitProjectDir(cwd), `terminal-history-${tabId}.jsonl`);
+}
+function getTerminalOutputPath(cwd, commandId) {
+  return join(getCockpitProjectDir(cwd), `terminal-output-${commandId}.txt`);
+}
+function getClaudeProjectDir(cwd) {
+  return join(CLAUDE_PROJECTS_DIR, encodePath(cwd));
+}
+function getClaudeSessionPath(cwd, sessionId) {
+  return join(getClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+}
+async function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+async function ensureParentDir(filePath) {
+  const dir = join(filePath, "..");
+  await ensureDir(dir);
+}
+async function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await ensureParentDir(filePath);
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+var fileLocks = /* @__PURE__ */ new Map();
+function withFileLock(filePath, fn) {
+  const prev = fileLocks.get(filePath) ?? Promise.resolve();
+  const run = prev.then(fn);
+  const chain = run.then(() => {
+  }, () => {
+  });
+  fileLocks.set(filePath, chain);
+  chain.then(() => {
+    if (fileLocks.get(filePath) === chain) {
+      fileLocks.delete(filePath);
+    }
+  });
+  return run;
+}
+
+// src/lib/global-state.ts
+import { createReadStream, existsSync as existsSync2 } from "fs";
+import { createInterface } from "readline";
+var MAX_SESSIONS = 15;
+var MAX_TEXT_LEN = 50;
+function truncate(s) {
+  if (!s) return s;
+  const chars = [...s];
+  return chars.length <= MAX_TEXT_LEN ? s : chars.slice(0, MAX_TEXT_LEN).join("") + "\u2026";
+}
+async function updateGlobalState(cwd, sessionId, status, title, lastUserMessage) {
+  if (!existsSync2(cwd)) {
+    return;
+  }
+  return withFileLock(GLOBAL_STATE_FILE, async () => {
+    const state = await readJsonFile(GLOBAL_STATE_FILE, { sessions: [] });
+    for (const s of state.sessions) {
+      if (!s.status) {
+        const legacy = s;
+        s.status = legacy.isLoading ? "loading" : "normal";
+        delete legacy.isLoading;
+      }
+    }
+    const existingIndex = state.sessions.findIndex(
+      (s) => s.cwd === cwd && s.sessionId === sessionId
+    );
+    const existing = existingIndex >= 0 ? state.sessions[existingIndex] : void 0;
+    const newSession = {
+      cwd,
+      sessionId,
+      lastActive: Date.now(),
+      status,
+      title: truncate(title || existing?.title),
+      lastUserMessage: truncate(lastUserMessage || existing?.lastUserMessage)
+    };
+    if (existingIndex >= 0) {
+      state.sessions[existingIndex] = newSession;
+    } else {
+      state.sessions.push(newSession);
+    }
+    state.sessions.sort((a, b) => b.lastActive - a.lastActive);
+    state.sessions = state.sessions.slice(0, MAX_SESSIONS);
+    await writeJsonFile(GLOBAL_STATE_FILE, state);
+  });
+}
+async function getSessionTitle(cwd, sessionId) {
+  const filePath = getClaudeSessionPath(cwd, sessionId);
+  if (!existsSync2(filePath)) {
+    return "Untitled Session";
+  }
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let summary = "";
+    const userMessages = [];
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "summary" && entry.summary) {
+          summary = entry.summary;
+        }
+        if (entry.type === "user") {
+          const message = entry.message;
+          if (message?.content) {
+            if (typeof message.content === "string") {
+              userMessages.push(message.content);
+            } else if (Array.isArray(message.content)) {
+              for (const block of message.content) {
+                if (block.type === "text" && block.text) {
+                  userMessages.push(block.text);
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return generateTitle(summary, userMessages);
+  } catch {
+    return "Untitled Session";
+  }
+}
+async function getLastUserMessage(cwd, sessionId) {
+  const filePath = getClaudeSessionPath(cwd, sessionId);
+  if (!existsSync2(filePath)) {
+    return void 0;
+  }
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let lastUserMessage;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user") {
+          const message = entry.message;
+          if (message?.content) {
+            let text = "";
+            if (typeof message.content === "string") {
+              text = message.content;
+            } else if (Array.isArray(message.content)) {
+              for (const block of message.content) {
+                if (block.type === "text" && block.text) {
+                  text = block.text;
+                  break;
+                }
+              }
+            }
+            if (text) {
+              const filtered = filterCommandTags(text);
+              if (filtered && isValidUserMessage(filtered)) {
+                lastUserMessage = filtered;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return lastUserMessage;
+  } catch {
+    return void 0;
+  }
+}
+function filterCommandTags(text) {
+  let filtered = text.replace(/<command-[^>]*>[\s\S]*?<\/command-[^>]*>/g, "");
+  filtered = filtered.replace(/<local-command-[^>]*>[\s\S]*?<\/local-command-[^>]*>/g, "");
+  filtered = filtered.trim();
+  return filtered;
+}
+function isValidUserMessage(text) {
+  if (text.startsWith("This session is being continued")) return false;
+  if (text.startsWith("Caveat: The messages below")) return false;
+  if (!text.trim()) return false;
+  return true;
+}
+function generateTitle(summary, userMessages) {
+  if (summary) return summary;
+  let commandName = "";
+  for (const msg of userMessages) {
+    const filtered = filterCommandTags(msg);
+    if (!filtered) continue;
+    if (filtered.startsWith("/") && !commandName) {
+      commandName = filtered;
+      continue;
+    }
+    if (commandName) {
+      return `${commandName} ${filtered}`;
+    }
+    return filtered;
+  }
+  if (commandName) return commandName;
+  return "Untitled Session";
+}
+
+export {
+  GLOBAL_STATE_FILE,
+  SCHEDULED_TASKS_FILE,
+  REVIEW_DIR,
+  REVIEW_SIGNAL_FILE,
+  getTerminalHistoryPath,
+  getTerminalOutputPath,
+  ensureParentDir,
+  readJsonFile,
+  writeJsonFile,
+  updateGlobalState,
+  getSessionTitle,
+  getLastUserMessage
+};

package/dist/scheduledTasks.mjs

@@ -0,0 +1,418 @@
+import {
+  SCHEDULED_TASKS_FILE,
+  getSessionTitle,
+  readJsonFile,
+  updateGlobalState,
+  writeJsonFile
+} from "./chunk-OER3N6H7.mjs";
+
+// src/lib/scheduledTasks.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+function parseCronField(field, min, max) {
+  const values = [];
+  for (const part of field.split(",")) {
+    if (part === "*") {
+      for (let i = min; i <= max; i++) values.push(i);
+    } else if (part.includes("/")) {
+      const [range, stepStr] = part.split("/");
+      const step = parseInt(stepStr, 10);
+      const start = range === "*" ? min : parseInt(range, 10);
+      for (let i = start; i <= max; i += step) values.push(i);
+    } else if (part.includes("-")) {
+      const [a, b] = part.split("-").map(Number);
+      for (let i = a; i <= b; i++) values.push(i);
+    } else {
+      values.push(parseInt(part, 10));
+    }
+  }
+  return values;
+}
+function getNextCronTime(cronExpr, after = /* @__PURE__ */ new Date()) {
+  const parts = cronExpr.trim().split(/\s+/);
+  if (parts.length !== 5) return after.getTime() + 6e4;
+  const minutes = parseCronField(parts[0], 0, 59);
+  const hours = parseCronField(parts[1], 0, 23);
+  const doms = parseCronField(parts[2], 1, 31);
+  const months = parseCronField(parts[3], 1, 12);
+  const dows = parseCronField(parts[4], 0, 6);
+  const candidate = new Date(after);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+  const limit = 366 * 24 * 60;
+  for (let i = 0; i < limit; i++) {
+    const m = candidate.getMinutes();
+    const h = candidate.getHours();
+    const d = candidate.getDate();
+    const mo = candidate.getMonth() + 1;
+    const dow = candidate.getDay();
+    if (minutes.includes(m) && hours.includes(h) && doms.includes(d) && months.includes(mo) && dows.includes(dow)) {
+      return candidate.getTime();
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+  return after.getTime() + 864e5;
+}
+async function sendChatMessage(task) {
+  try {
+    const options = {
+      resume: task.sessionId,
+      cwd: task.cwd,
+      settingSources: ["user", "project", "local"],
+      allowedTools: [
+        "Read",
+        "Write",
+        "Edit",
+        "Bash",
+        "Glob",
+        "Grep",
+        "WebFetch",
+        "WebSearch",
+        "Task",
+        "TodoWrite",
+        "mcp__*"
+      ],
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      betas: ["context-1m-2025-08-07"]
+    };
+    await updateGlobalState(task.cwd, task.sessionId, "loading", void 0, task.message).catch(() => {
+    });
+    const response = query({
+      prompt: task.message,
+      options
+    });
+    for await (const _message of response) {
+    }
+    const title = await getSessionTitle(task.cwd, task.sessionId);
+    await updateGlobalState(task.cwd, task.sessionId, "unread", title);
+    return true;
+  } catch (error) {
+    console.error(`[ScheduledTask] Failed to send message for task ${task.id}:`, error);
+    await updateGlobalState(task.cwd, task.sessionId, "unread").catch(() => {
+    });
+    return false;
+  }
+}
+var ScheduledTaskManager = class {
+  constructor() {
+    this.tasks = [];
+    this.timers = /* @__PURE__ */ new Map();
+    this.port = 0;
+    this.initialized = false;
+    this.initPromise = null;
+    this.onTaskFired = null;
+  }
+  /**
+   * Return the current port (from explicit init or environment variables).
+   */
+  getPort() {
+    if (this.port) return this.port;
+    const envPort = parseInt(process.env.COCKPIT_PORT || "0", 10);
+    if (envPort) {
+      this.port = envPort;
+      return this.port;
+    }
+    const isDev = process.env.COCKPIT_ENV === "dev";
+    this.port = isDev ? 3456 : 3457;
+    return this.port;
+  }
+  /**
+   * Ensure the manager is initialized (lazy init; supports calls from different module instances in API routes).
+   */
+  async ensureInit() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    const port = this.getPort();
+    if (!port) return;
+    this.initPromise = this.init(port);
+    return this.initPromise;
+  }
+  /**
+   * Initialize: load tasks from disk and rebuild timers.
+   */
+  async init(port) {
+    if (this.initialized) return;
+    this.port = port;
+    this.initialized = true;
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    this.tasks = allTasks.filter((t) => t.port === port);
+    console.log(`[ScheduledTaskManager] Loaded ${this.tasks.length} tasks for port ${port}`);
+    for (const task of this.tasks) {
+      if (!task.paused && !task.completed) {
+        this.scheduleTask(task);
+      }
+    }
+    await this.saveToDisk();
+  }
+  /**
+   * Register a task-fired callback (used for WS broadcast).
+   */
+  setOnTaskFired(cb) {
+    this.onTaskFired = cb;
+  }
+  /**
+   * Read tasks for the current port from disk (avoids in-memory inconsistency between dual module instances).
+   */
+  async readTasksFromDisk() {
+    const port = this.getPort();
+    if (!port) return [];
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    return allTasks.filter((t) => t.port === port);
+  }
+  /**
+   * Return all tasks for the current instance (reads from disk each time to ensure cross-instance consistency).
+   */
+  async getTasks() {
+    await this.ensureInit();
+    const tasks = await this.readTasksFromDisk();
+    tasks.sort((a, b) => (a.sortIndex ?? a.createdAt) - (b.sortIndex ?? b.createdAt));
+    return tasks;
+  }
+  /**
+   * Return the count of unread tasks (reads from disk each time).
+   */
+  async getUnreadCount() {
+    await this.ensureInit();
+    const tasks = await this.readTasksFromDisk();
+    return tasks.filter((t) => t.unread).length;
+  }
+  /**
+   * Add a task.
+   */
+  async addTask(task) {
+    await this.ensureInit();
+    const fullTask = { ...task, port: this.getPort() };
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    allTasks.push(fullTask);
+    await writeJsonFile(SCHEDULED_TASKS_FILE, allTasks);
+    this.tasks.push(fullTask);
+    if (!fullTask.paused && !fullTask.completed) {
+      this.scheduleTask(fullTask);
+    }
+    return fullTask;
+  }
+  /**
+   * Update a task (read → modify → write to disk; avoids dual-instance issues).
+   */
+  async updateTask(id, fields) {
+    await this.ensureInit();
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    const idx = allTasks.findIndex((t) => t.id === id);
+    if (idx === -1) return null;
+    const task = { ...allTasks[idx], ...fields };
+    allTasks[idx] = task;
+    await writeJsonFile(SCHEDULED_TASKS_FILE, allTasks);
+    const memIdx = this.tasks.findIndex((t) => t.id === id);
+    if (memIdx !== -1) {
+      this.tasks[memIdx] = task;
+      this.clearTimer(id);
+      if (!task.paused && !task.completed) {
+        this.scheduleTask(task);
+      }
+    }
+    return task;
+  }
+  /**
+   * Delete a task (read → modify → write to disk; avoids dual-instance issues).
+   */
+  async deleteTask(id) {
+    await this.ensureInit();
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    const idx = allTasks.findIndex((t) => t.id === id);
+    if (idx === -1) return false;
+    allTasks.splice(idx, 1);
+    await writeJsonFile(SCHEDULED_TASKS_FILE, allTasks);
+    const memIdx = this.tasks.findIndex((t) => t.id === id);
+    if (memIdx !== -1) {
+      this.clearTimer(id);
+      this.tasks.splice(memIdx, 1);
+    }
+    return true;
+  }
+  /**
+   * Pause a task.
+   */
+  async pauseTask(id) {
+    return this.updateTask(id, { paused: true });
+  }
+  /**
+   * Resume a task.
+   */
+  async resumeTask(id) {
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    const task = allTasks.find((t) => t.id === id);
+    if (!task) return null;
+    const now = Date.now();
+    let nextFireTime = task.nextFireTime;
+    if (nextFireTime <= now) {
+      if (task.type === "interval" && task.intervalMinutes) {
+        nextFireTime = now + task.intervalMinutes * 6e4;
+      } else if (task.type === "cron" && task.cron) {
+        nextFireTime = getNextCronTime(task.cron);
+      } else {
+        nextFireTime = now + 6e4;
+      }
+    }
+    return this.updateTask(id, { paused: false, nextFireTime });
+  }
+  /**
+   * Manually trigger a task (runs in the background; returns immediately; does not affect the existing schedule).
+   * Skips paused / activeRange checks and sends the message directly.
+   */
+  async triggerTask(id) {
+    await this.ensureInit();
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    const task = allTasks.find((t) => t.id === id);
+    if (!task) return;
+    const memIdx = this.tasks.findIndex((t) => t.id === id);
+    if (memIdx !== -1) {
+      this.tasks[memIdx] = task;
+    } else {
+      this.tasks.push(task);
+    }
+    this.fireTaskManual(id).catch((err) => {
+      console.error(`[ScheduledTask] Manual trigger failed for ${id}:`, err);
+    });
+  }
+  /** Internal implementation for manual trigger; skips paused / activeRange checks. */
+  async fireTaskManual(id) {
+    const task = this.tasks.find((t) => t.id === id);
+    if (!task) return;
+    console.log(`[ScheduledTask] Manual trigger ${id}: "${task.message}"`);
+    const success = await sendChatMessage(task);
+    task.lastFiredAt = Date.now();
+    task.lastResult = success ? "success" : "error";
+    task.unread = true;
+    await this.saveToDisk();
+    if (this.onTaskFired) {
+      this.onTaskFired(task);
+    }
+  }
+  /**
+   * Mark a task as read.
+   */
+  async markRead(id) {
+    await this.updateTask(id, { unread: false });
+  }
+  /**
+   * Mark all tasks as read (operates directly on disk; avoids dual-instance issues).
+   */
+  async markAllRead() {
+    await this.ensureInit();
+    const port = this.getPort();
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    let changed = false;
+    for (const task of allTasks) {
+      if (task.port === port && task.unread) {
+        task.unread = false;
+        changed = true;
+      }
+    }
+    if (changed) await writeJsonFile(SCHEDULED_TASKS_FILE, allTasks);
+  }
+  /**
+   * Reorder tasks by writing sortIndex values based on the given id array order.
+   */
+  async reorderTasks(orderedIds) {
+    await this.ensureInit();
+    const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+    for (let i = 0; i < orderedIds.length; i++) {
+      const task = allTasks.find((t) => t.id === orderedIds[i]);
+      if (task) task.sortIndex = i;
+    }
+    await writeJsonFile(SCHEDULED_TASKS_FILE, allTasks);
+  }
+  // ---- Internal ----
+  /**
+   * Schedule a task. If nextFireTime has already passed, recalculate the next fire time instead of firing immediately.
+   * Returns true if a timer was set, or false if the task has expired and cannot be rescheduled (once type).
+   */
+  scheduleTask(task) {
+    const now = Date.now();
+    if (task.nextFireTime <= now) {
+      if (task.type === "interval" && task.intervalMinutes) {
+        task.nextFireTime = now + task.intervalMinutes * 6e4;
+      } else if (task.type === "cron" && task.cron) {
+        task.nextFireTime = getNextCronTime(task.cron);
+      } else {
+        task.completed = true;
+        return false;
+      }
+    }
+    const delay = task.nextFireTime - now;
+    const timer = setTimeout(() => {
+      this.fireTask(task.id);
+    }, delay);
+    this.timers.set(task.id, timer);
+    return true;
+  }
+  clearTimer(id) {
+    const timer = this.timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(id);
+    }
+  }
+  /**
+   * Check whether the current time falls within the active time range for an interval task.
+   */
+  isInActiveRange(task) {
+    if (task.type !== "interval" || !task.activeFrom || !task.activeTo) return true;
+    const now = /* @__PURE__ */ new Date();
+    const [fh, fm] = task.activeFrom.split(":").map(Number);
+    const [th, tm] = task.activeTo.split(":").map(Number);
+    const current = now.getHours() * 60 + now.getMinutes();
+    const from = fh * 60 + fm;
+    const to = th * 60 + tm;
+    if (from <= to) {
+      return current >= from && current <= to;
+    } else {
+      return current >= from || current <= to;
+    }
+  }
+  async fireTask(id) {
+    const task = this.tasks.find((t) => t.id === id);
+    if (!task || task.paused) return;
+    if (!this.isInActiveRange(task)) {
+      console.log(`[ScheduledTask] Skipping task ${id}: outside active range ${task.activeFrom}-${task.activeTo}`);
+      if (task.type === "interval" && task.intervalMinutes) {
+        task.nextFireTime = Date.now() + task.intervalMinutes * 6e4;
+        this.scheduleTask(task);
+        await this.saveToDisk();
+      }
+      return;
+    }
+    console.log(`[ScheduledTask] Firing task ${id}: "${task.message}"`);
+    const success = await sendChatMessage(task);
+    task.lastFiredAt = Date.now();
+    task.lastResult = success ? "success" : "error";
+    task.unread = true;
+    if (task.type === "once") {
+      task.completed = true;
+    } else if (task.type === "interval" && task.intervalMinutes) {
+      task.nextFireTime = Date.now() + task.intervalMinutes * 6e4;
+      this.scheduleTask(task);
+    } else if (task.type === "cron" && task.cron) {
+      task.nextFireTime = getNextCronTime(task.cron);
+      this.scheduleTask(task);
+    }
+    await this.saveToDisk();
+    if (this.onTaskFired) {
+      this.onTaskFired(task);
+    }
+  }
+  async saveToDisk() {
+    try {
+      const allTasks = await readJsonFile(SCHEDULED_TASKS_FILE, []);
+      const otherTasks = allTasks.filter((t) => t.port !== this.port);
+      await writeJsonFile(SCHEDULED_TASKS_FILE, [...otherTasks, ...this.tasks]);
+    } catch (error) {
+      console.error("[ScheduledTaskManager] Failed to save:", error);
+    }
+  }
+};
+var scheduledTaskManager = new ScheduledTaskManager();
+export {
+  getNextCronTime,
+  scheduledTaskManager
+};