@serviceme/devtools-core 0.0.5 → 0.1.2

package/dist/index.mjs

@@ -5,11 +5,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/env/environmentInspector.ts
+// src/copilot/doctor.ts
 import {
-  KNOWN_ENVIRONMENT_TOOLS
+  COPILOT_ERROR_CODES,
+  createServicemeError
 } from "@serviceme/devtools-protocol";
-import { createServicemeError } from "@serviceme/devtools-protocol";
 
 // src/process/runCommand.ts
 import { spawn } from "child_process";
@@ -119,19 +119,144 @@ async function commandExists(command) {
   }
 }
 
+// src/copilot/doctor.ts
+var COPILOT_COMMAND = "copilot";
+var GH_COMMAND = "gh";
+async function isCopilotAuthenticated() {
+  try {
+    await runCommand(GH_COMMAND, {
+      args: ["auth", "status"],
+      timeoutMs: 1e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copilotDoctor() {
+  const exists = await commandExists(COPILOT_COMMAND);
+  if (!exists) {
+    return { installed: false, version: null, authenticated: false };
+  }
+  let version = null;
+  try {
+    const versionResult = await runCommand(COPILOT_COMMAND, {
+      args: ["--version"],
+      timeoutMs: 1e4
+    });
+    version = versionResult.stdout.trim();
+  } catch {
+    return { installed: true, version: null, authenticated: false };
+  }
+  const authenticated = await isCopilotAuthenticated();
+  return { installed: true, version, authenticated };
+}
+function createCopilotNotInstalledError() {
+  return createServicemeError(
+    COPILOT_ERROR_CODES.NOT_INSTALLED,
+    "GitHub Copilot CLI is not installed. Visit https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-in-the-command-line to install."
+  );
+}
+function createCopilotAuthRequiredError() {
+  return createServicemeError(
+    COPILOT_ERROR_CODES.AUTH_REQUIRED,
+    "GitHub Copilot CLI requires authentication. Run `copilot auth login` to sign in."
+  );
+}
+
+// src/copilot/prompt.ts
+import {
+  COPILOT_ERROR_CODES as COPILOT_ERROR_CODES2,
+  createServicemeError as createServicemeError2
+} from "@serviceme/devtools-protocol";
+var COPILOT_COMMAND2 = "copilot";
+var DEFAULT_TIMEOUT_MS = 12e4;
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "");
+}
+async function copilotPrompt(options) {
+  const args = ["-p", options.prompt];
+  if (options.workspace) {
+    args.push("--add-dir", options.workspace);
+  }
+  if (options.autopilot) {
+    args.push("--allow-all-tools");
+  }
+  if (options.allowTools?.length) {
+    for (const tool of options.allowTools) {
+      args.push("--allow-tool", tool);
+    }
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.agent) {
+    args.push("--agent", options.agent);
+  }
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+  try {
+    const result = await runCommand(COPILOT_COMMAND2, {
+      args,
+      cwd: options.workspace,
+      timeoutMs: timeout
+    });
+    const output = stripAnsi(result.stdout);
+    if (output.includes("I'm sorry, but I cannot assist") && result.stderr?.includes("Stream completed without a response")) {
+      throw createServicemeError2(
+        COPILOT_ERROR_CODES2.AUTH_REQUIRED,
+        "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
+        { exitCode: 0, output, stderr: result.stderr }
+      );
+    }
+    return { output, exitCode: 0 };
+  } catch (error) {
+    const err = error;
+    if (err.code === "ETIMEDOUT") {
+      throw createServicemeError2(
+        COPILOT_ERROR_CODES2.TIMEOUT,
+        `Copilot prompt timed out after ${String(timeout)}ms.`
+      );
+    }
+    const exitCode = typeof err.code === "number" ? err.code : 1;
+    const output = stripAnsi(err.stdout ?? "");
+    const stderr = err.stderr ?? err.message ?? "";
+    if (output.includes("I'm sorry, but I cannot assist") || stderr.includes("Stream completed without a response")) {
+      throw createServicemeError2(
+        COPILOT_ERROR_CODES2.AUTH_REQUIRED,
+        "Copilot CLI returned a refusal response. This typically indicates an expired authentication token. Run `gh auth login` to re-authenticate.",
+        { exitCode, output, stderr }
+      );
+    }
+    if (exitCode !== 0 && output) {
+      return { output, exitCode };
+    }
+    throw createServicemeError2(
+      COPILOT_ERROR_CODES2.EXECUTION_FAILED,
+      stderr || `Copilot exited with code ${String(exitCode)}.`,
+      { exitCode, stderr }
+    );
+  }
+}
+
 // src/env/environmentInspector.ts
+import {
+  createServicemeError as createServicemeError3,
+  KNOWN_ENVIRONMENT_TOOLS
+} from "@serviceme/devtools-protocol";
 var TOOL_CHECK_TIMEOUT_MS = 5e3;
 var ERROR_CODE_NOT_FOUND = 127;
 var EnvironmentInspector = class {
   async checkEnvironment() {
     const results = await Promise.all(
-      KNOWN_ENVIRONMENT_TOOLS.map(async (tool) => [tool, await this.checkTool(tool)])
+      KNOWN_ENVIRONMENT_TOOLS.map(
+        async (tool) => [tool, await this.checkTool(tool)]
+      )
     );
     return Object.fromEntries(results);
   }
   async checkTool(toolName) {
     if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
-      throw createServicemeError("invalid_params", "Invalid tool name.");
+      throw createServicemeError3("invalid_params", "Invalid tool name.");
     }
     try {
       if (toolName === "nvm") {
@@ -289,9 +414,17 @@ var EnvironmentInspector = class {
 import * as fs from "fs/promises";
 import * as path from "path";
 import {
-  createServicemeError as createServicemeError2
+  createServicemeError as createServicemeError4
 } from "@serviceme/devtools-protocol";
-var SUPPORTED_FORMATS = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff"];
+var SUPPORTED_FORMATS = [
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".gif",
+  ".bmp",
+  ".tiff"
+];
 var DEFAULT_MINIMUM_COMPRESSION_RATIO = 5;
 var ImageTools = class {
   getSupportedFormats() {
@@ -326,7 +459,10 @@ var ImageTools = class {
   async compress(imagePath, options) {
     const validation = await this.validate(imagePath, options.sharpModulePath);
     if (!validation.valid) {
-      throw createServicemeError2("invalid_params", `Invalid image file: ${imagePath}`);
+      throw createServicemeError4(
+        "invalid_params",
+        `Invalid image file: ${imagePath}`
+      );
     }
     const originalStats = await fs.stat(imagePath);
     const originalSize = originalStats.size;
@@ -397,7 +533,7 @@ var ImageTools = class {
     try {
       return sharpModulePath ? __require(sharpModulePath) : __require("sharp");
     } catch (error) {
-      throw createServicemeError2(
+      throw createServicemeError4(
         "internal_error",
         `sharp is required for image operations: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -409,12 +545,12 @@ function createImageTools() {
 }
 
 // src/json/jsonTools.ts
-import { parse as parseCommentJson } from "comment-json";
-import JSON5 from "json5";
 import {
+  createServicemeError as createServicemeError5,
   DEFAULT_JSON_SORT_OPTIONS
 } from "@serviceme/devtools-protocol";
-import { createServicemeError as createServicemeError3 } from "@serviceme/devtools-protocol";
+import { parse as parseCommentJson } from "comment-json";
+import JSON5 from "json5";
 function createJsonTools() {
   return {
     sort(text, options) {
@@ -454,7 +590,7 @@ function parseJson(text) {
     } catch {
     }
   }
-  throw createServicemeError3("json_invalid_input", "Invalid JSON format.");
+  throw createServicemeError5("json_invalid_input", "Invalid JSON format.");
 }
 function sortObject(obj, options) {
   if (Array.isArray(obj)) {
@@ -480,9 +616,6 @@ function sortKeys(keys, options) {
     case "alphaNum":
       compareFn = (a, b) => a.localeCompare(b, void 0, { numeric: true });
       break;
-    case "values":
-    case "type":
-    case "default":
     default:
       compareFn = (a, b) => a.localeCompare(b);
       break;
@@ -526,8 +659,10 @@ function formatArgs(args) {
 function createConsoleLogger(prefix = "serviceme") {
   return {
     debug(message, ...args) {
-      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
-`);
+      process.stderr.write(
+        `[${prefix}] DEBUG ${message} ${formatArgs(args)}
+`
+      );
     },
     info(message, ...args) {
       process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
@@ -538,404 +673,19 @@ function createConsoleLogger(prefix = "serviceme") {
 `);
     },
     error(message, ...args) {
-      process.stderr.write(`[${prefix}] ERROR ${message} ${formatArgs(args)}
-`);
+      process.stderr.write(
+        `[${prefix}] ERROR ${message} ${formatArgs(args)}
+`
+      );
     }
   };
 }
 
-// src/opencode/OpenCodeManager.ts
-import { spawn as spawn2 } from "child_process";
-import { randomInt } from "crypto";
-import {
-  createServicemeError as createServicemeError4
-} from "@serviceme/devtools-protocol";
-var DEFAULT_OPTIONS = {
-  command: "opencode",
-  installUrl: "https://opencode.ai",
-  host: "127.0.0.1",
-  portMin: 16384,
-  portMax: 65535,
-  healthPath: "/app",
-  sessionPath: "/session",
-  sessionStatusPath: "/session/status",
-  startupPollIntervalMs: 200,
-  idleTimeoutMs: 10 * 60 * 1e3,
-  stdoutLogLimitBytes: 64 * 1024
-};
-var OpenCodeManager = class {
-  constructor(options = {}) {
-    this.stdoutBytes = 0;
-    this.options = {
-      ...DEFAULT_OPTIONS,
-      ...options
-    };
-    this.logger = options.logger ?? noopLogger;
-  }
-  async isAvailable() {
-    return commandExists(this.options.command);
-  }
-  isRunning() {
-    return Boolean(this.childProcess && !this.childProcess.killed && this.port);
-  }
-  async ensureServer(runtime = {}) {
-    await this.ensureServerStarted(runtime);
-    return this.getServerState();
-  }
-  async getServerState() {
-    const available = await this.isAvailable();
-    const running = this.isRunning();
-    const healthy = this.port ? await this.isServerHealthy(this.port) : false;
-    return {
-      available,
-      running,
-      healthy,
-      installUrl: this.options.installUrl,
-      pid: this.childProcess?.pid,
-      port: this.port
-    };
-  }
-  async createSession(runtime = {}) {
-    await this.ensureServerStarted(runtime);
-    const session = await this.request(
-      this.options.sessionPath,
-      {
-        method: "POST",
-        query: this.createQuery(runtime.workspaceRoot),
-        body: {}
-      }
-    );
-    this.resetIdleTimer();
-    return {
-      sessionId: session.id,
-      title: session.title,
-      status: "running"
-    };
-  }
-  async prompt(input) {
-    await this.ensureServerStarted({ workspaceRoot: input.workspaceRoot });
-    await this.request(
-      `${this.options.sessionPath}/${input.sessionId}/message`,
-      {
-        method: "POST",
-        query: this.createQuery(input.workspaceRoot),
-        body: {
-          parts: [
-            {
-              type: "text",
-              text: input.prompt
-            }
-          ]
-        },
-        signal: input.signal
-      }
-    );
-    const latestMessage = await this.getLatestAssistantMessage(
-      input.sessionId,
-      input.workspaceRoot,
-      input.signal
-    );
-    input.onEvent?.({
-      type: "status",
-      status: "running"
-    });
-    if (latestMessage) {
-      input.onEvent?.({
-        type: "message",
-        text: latestMessage
-      });
-    }
-    input.onEvent?.({
-      type: "completed"
-    });
-    this.resetIdleTimer();
-  }
-  async getSessionStatus(sessionId, workspaceRoot) {
-    await this.ensureServerStarted({ workspaceRoot });
-    const response = await this.request(this.options.sessionStatusPath, {
-      method: "GET",
-      query: this.createQuery(workspaceRoot)
-    });
-    const session = response.find((item) => item.id === sessionId);
-    this.resetIdleTimer();
-    return this.mapStatus(session?.status);
-  }
-  async abortSession(sessionId, workspaceRoot) {
-    await this.ensureServerStarted({ workspaceRoot });
-    await this.request(`${this.options.sessionPath}/${sessionId}/abort`, {
-      method: "POST",
-      query: this.createQuery(workspaceRoot)
-    });
-    this.resetIdleTimer();
-  }
-  async dispose() {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = void 0;
-    }
-    await this.terminateTrackedProcess("dispose");
-    this.startupPromise = void 0;
-  }
-  async ensureServerStarted(runtime) {
-    if (this.port) {
-      if (await this.isServerHealthy(this.port)) {
-        return;
-      }
-      await this.terminateTrackedProcess("restart-unhealthy");
-    }
-    if (this.startupPromise) {
-      await this.startupPromise;
-      return;
-    }
-    if (!await this.isAvailable()) {
-      throw createServicemeError4(
-        "opencode_not_installed",
-        "OpenCode CLI is not installed."
-      );
-    }
-    const MAX_PORT_RETRIES = 3;
-    let lastError;
-    for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
-      this.startupPromise = this.startServerProcess(runtime);
-      try {
-        await this.startupPromise;
-        return;
-      } catch (error) {
-        lastError = error;
-        this.logger.warn(
-          `OpenCode server start attempt ${String(attempt + 1)} failed, retrying...`
-        );
-      } finally {
-        this.startupPromise = void 0;
-      }
-    }
-    throw lastError;
-  }
-  async startServerProcess(runtime) {
-    const port = randomInt(this.options.portMin, this.options.portMax + 1);
-    const child = spawn2(this.options.command, ["--port", String(port)], {
-      cwd: runtime.workspaceRoot,
-      detached: process.platform !== "win32",
-      env: {
-        ...process.env,
-        OPENCODE_CALLER: "serviceme-cli"
-      },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    this.stdoutBytes = 0;
-    child.stdout?.on("data", (chunk) => {
-      if (this.stdoutBytes < this.options.stdoutLogLimitBytes) {
-        this.logger.debug("OpenCode stdout", chunk.toString());
-        this.stdoutBytes += chunk.length;
-      }
-    });
-    child.stderr?.on("data", (chunk) => {
-      this.logger.warn("OpenCode stderr", chunk.toString());
-    });
-    child.on("error", (error) => {
-      this.logger.error("OpenCode process error", error);
-      if (this.childProcess === child) {
-        this.childProcess = void 0;
-        this.port = void 0;
-      }
-    });
-    child.on("exit", () => {
-      if (this.childProcess === child) {
-        this.childProcess = void 0;
-        this.port = void 0;
-      }
-    });
-    if (process.platform !== "win32" && child.pid) {
-      spawn2("renice", ["+10", String(child.pid)], { stdio: "ignore" }).unref();
-    }
-    this.childProcess = child;
-    this.port = port;
-    const ready = await this.waitForHealth(
-      port,
-      runtime.startupTimeoutMs ?? 5e3
-    );
-    if (!ready) {
-      await this.terminateTrackedProcess("startup-timeout");
-      throw createServicemeError4(
-        "opencode_startup_timeout",
-        "OpenCode local server did not start in time."
-      );
-    }
-  }
-  async waitForHealth(port, timeoutMs) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-      if (await this.isServerHealthy(port)) {
-        return true;
-      }
-      await new Promise((resolve) => {
-        setTimeout(resolve, this.options.startupPollIntervalMs);
-      });
-    }
-    return false;
-  }
-  async isServerHealthy(port) {
-    try {
-      const response = await fetch(
-        `http://${this.options.host}:${port}${this.options.healthPath}`
-      );
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  resetIdleTimer() {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-    }
-    this.idleTimer = setTimeout(() => {
-      void this.dispose();
-    }, this.options.idleTimeoutMs);
-    this.idleTimer.unref?.();
-  }
-  async terminateTrackedProcess(reason) {
-    const child = this.childProcess;
-    this.childProcess = void 0;
-    this.port = void 0;
-    if (!child || child.killed) {
-      return;
-    }
-    this.logger.info("Stopping tracked OpenCode process", {
-      reason,
-      pid: child.pid
-    });
-    if (process.platform === "win32") {
-      if (child.pid) {
-        await new Promise((resolve) => {
-          const killProcess = spawn2(
-            "taskkill",
-            ["/pid", String(child.pid), "/T", "/F"],
-            {
-              stdio: "ignore",
-              windowsHide: true
-            }
-          );
-          killProcess.once("exit", () => resolve());
-          killProcess.once("error", () => {
-            child.kill();
-            resolve();
-          });
-        });
-        return;
-      }
-      child.kill();
-      return;
-    }
-    if (!child.pid) {
-      child.kill("SIGTERM");
-      return;
-    }
-    try {
-      process.kill(-child.pid, "SIGTERM");
-    } catch {
-      child.kill("SIGTERM");
-      return;
-    }
-    const childPid = child.pid;
-    await new Promise((resolve) => {
-      const escalationTimer = setTimeout(() => {
-        try {
-          process.kill(-childPid, "SIGKILL");
-        } catch {
-        }
-        resolve();
-      }, 2e3);
-      child.once("exit", () => {
-        clearTimeout(escalationTimer);
-        try {
-          process.kill(-childPid, "SIGKILL");
-        } catch {
-        }
-        resolve();
-      });
-    });
-  }
-  async request(path3, options) {
-    if (!this.port) {
-      throw createServicemeError4(
-        "opencode_backend_not_running",
-        "OpenCode local server is not running."
-      );
-    }
-    const url = new URL(`http://${this.options.host}:${this.port}${path3}`);
-    for (const [key, value] of Object.entries(options.query ?? {})) {
-      if (value) {
-        url.searchParams.set(key, value);
-      }
-    }
-    const response = await fetch(url, {
-      method: options.method,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: options.body ? JSON.stringify(options.body) : void 0,
-      signal: options.signal
-    });
-    if (!response.ok) {
-      throw createServicemeError4(
-        "opencode_request_failed",
-        `OpenCode request failed: ${response.status} ${response.statusText}`
-      );
-    }
-    if (response.status === 204) {
-      return void 0;
-    }
-    return await response.json();
-  }
-  createQuery(workspaceRoot) {
-    return {
-      directory: workspaceRoot
-    };
-  }
-  async getLatestAssistantMessage(sessionId, workspaceRoot, signal) {
-    const messages = await this.request(
-      `${this.options.sessionPath}/${sessionId}/message`,
-      {
-        method: "GET",
-        query: {
-          ...this.createQuery(workspaceRoot),
-          limit: "20"
-        },
-        signal
-      }
-    );
-    const latestAssistant = [...messages].reverse().find((message) => message.info?.role === "assistant");
-    if (!latestAssistant?.parts) {
-      return void 0;
-    }
-    return latestAssistant.parts.filter(
-      (part) => part.type === "text" && typeof part.text === "string"
-    ).map((part) => part.text).join("\n\n");
-  }
-  mapStatus(status) {
-    switch (status) {
-      case "running":
-      case "active":
-        return "running";
-      case "needs_input":
-        return "needs-input";
-      case "completed":
-        return "completed";
-      case "failed":
-        return "failed";
-      case "aborted":
-        return "aborted";
-      default:
-        return "idle";
-    }
-  }
-};
-
 // src/project/projectTools.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
 import {
-  createServicemeError as createServicemeError5
+  createServicemeError as createServicemeError6
 } from "@serviceme/devtools-protocol";
 
 // src/utils/fileUtils.ts
@@ -953,39 +703,49 @@ import { dirname as dirname2, join as join2 } from "path";
 import { open } from "yauzl";
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve, reject) => {
-    open(zipPath, { lazyEntries: true }, (err, zipfile) => {
-      if (err) return reject(err);
-      if (!zipfile) return reject(new Error("Failed to open zip file."));
-      zipfile.readEntry();
-      zipfile.on("entry", (entry) => {
-        if (/\/$/.test(entry.fileName)) {
-          void mkdir(join2(dest, entry.fileName), { recursive: true }).then(() => {
-            zipfile.readEntry();
-          }).catch(reject);
-        } else {
-          const outputPath = join2(dest, entry.fileName);
-          void mkdir(dirname2(outputPath), { recursive: true }).then(() => {
-            zipfile.openReadStream(entry, (streamError, readStream) => {
-              if (streamError) return reject(streamError);
-              if (!readStream) return reject(new Error("Failed to open zip entry stream."));
-              const writeStream = createWriteStream(outputPath);
-              readStream.on("error", reject);
-              writeStream.on("error", reject);
-              writeStream.on("close", () => {
-                zipfile.readEntry();
-              });
-              readStream.pipe(writeStream);
-            });
-          }).catch(reject);
-        }
-      });
-      zipfile.on("end", () => {
-        resolve();
-      });
-      zipfile.on("error", (zipError) => {
-        reject(zipError);
-      });
-    });
+    open(
+      zipPath,
+      { lazyEntries: true },
+      (err, zipfile) => {
+        if (err) return reject(err);
+        if (!zipfile) return reject(new Error("Failed to open zip file."));
+        zipfile.readEntry();
+        zipfile.on("entry", (entry) => {
+          if (/\/$/.test(entry.fileName)) {
+            void mkdir(join2(dest, entry.fileName), { recursive: true }).then(() => {
+              zipfile.readEntry();
+            }).catch(reject);
+          } else {
+            const outputPath = join2(dest, entry.fileName);
+            void mkdir(dirname2(outputPath), { recursive: true }).then(() => {
+              zipfile.openReadStream(
+                entry,
+                (streamError, readStream) => {
+                  if (streamError) return reject(streamError);
+                  if (!readStream)
+                    return reject(
+                      new Error("Failed to open zip entry stream.")
+                    );
+                  const writeStream = createWriteStream(outputPath);
+                  readStream.on("error", reject);
+                  writeStream.on("error", reject);
+                  writeStream.on("close", () => {
+                    zipfile.readEntry();
+                  });
+                  readStream.pipe(writeStream);
+                }
+              );
+            }).catch(reject);
+          }
+        });
+        zipfile.on("end", () => {
+          resolve();
+        });
+        zipfile.on("error", (zipError) => {
+          reject(zipError);
+        });
+      }
+    );
   });
 };
 var tryLstat = async (targetPath) => {
@@ -1009,7 +769,11 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await mkdir(destPath, { recursive: true });
     const children = await readdir(sourcePath);
     for (const child of children) {
-      await mergeEntry(join2(sourcePath, child), join2(destPath, child), overwrite);
+      await mergeEntry(
+        join2(sourcePath, child),
+        join2(destPath, child),
+        overwrite
+      );
     }
     await rm(sourcePath, { recursive: true, force: true });
     return;
@@ -1086,7 +850,7 @@ var ProjectTools = class {
   }
   async installDependencies(workspacePath, command) {
     if (!command) {
-      throw createServicemeError5("invalid_params", "Expected install command.");
+      throw createServicemeError6("invalid_params", "Expected install command.");
     }
     await runCommand(command, {
       cwd: workspacePath,
@@ -1149,7 +913,7 @@ var ProjectTools = class {
   }
   async runScaffoldPrune(workspacePath, preset) {
     if (!preset) {
-      throw createServicemeError5("invalid_params", "Expected scaffold preset.");
+      throw createServicemeError6("invalid_params", "Expected scaffold preset.");
     }
     const commands = [
       `pnpm run scaffold:prune -- --preset ${preset} --project-root .`,
@@ -1229,16 +993,971 @@ var ProjectTools = class {
 function createProjectTools() {
   return new ProjectTools();
 }
+
+// src/scheduled-tasks/daemon/DaemonLogger.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var CONFIG_DIR = ".serviceme";
+var LOG_FILE = "scheduler.log";
+var MAX_LOG_SIZE = 1024 * 1024;
+var DaemonLogger = class {
+  constructor(workspacePath) {
+    this.logPath = path3.join(workspacePath, CONFIG_DIR, LOG_FILE);
+    const dir = path3.dirname(this.logPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+  log(level, message) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${level.toUpperCase()}] ${message}
+`;
+    this.rotateIfNeeded();
+    fs3.appendFileSync(this.logPath, line, "utf-8");
+  }
+  rotateIfNeeded() {
+    try {
+      const stats = fs3.statSync(this.logPath);
+      if (stats.size > MAX_LOG_SIZE) {
+        const content = fs3.readFileSync(this.logPath, "utf-8");
+        const halfIdx = content.indexOf("\n", Math.floor(content.length / 2));
+        if (halfIdx > 0) {
+          fs3.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/scheduled-tasks/daemon/PidManager.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var CONFIG_DIR2 = ".serviceme";
+var PID_FILE = "scheduler.pid";
+var PidManager = class {
+  constructor(workspacePath) {
+    this.pidPath = path4.join(workspacePath, CONFIG_DIR2, PID_FILE);
+  }
+  getPidPath() {
+    return this.pidPath;
+  }
+  writePid(pid) {
+    const dir = path4.dirname(this.pidPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(this.pidPath, String(pid), "utf-8");
+  }
+  readPid() {
+    if (!fs4.existsSync(this.pidPath)) return null;
+    const raw = fs4.readFileSync(this.pidPath, "utf-8").trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isNaN(pid) ? null : pid;
+  }
+  removePid() {
+    if (fs4.existsSync(this.pidPath)) {
+      fs4.unlinkSync(this.pidPath);
+    }
+  }
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getRunningPid() {
+    const pid = this.readPid();
+    if (pid === null) return null;
+    if (this.isProcessRunning(pid)) return pid;
+    this.removePid();
+    return null;
+  }
+};
+
+// src/scheduled-tasks/daemon/SchedulerDaemon.ts
+import * as fs7 from "fs";
+
+// src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_TIMEOUT = 3e5;
+var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+var GithubCopilotCliExecutor = class {
+  async execute(payload, abortSignal) {
+    const authenticated = await isCopilotAuthenticated();
+    if (!authenticated) {
+      return {
+        status: "failure",
+        error: "GitHub Copilot CLI authentication failed. Please run `gh auth login` to re-authenticate."
+      };
+    }
+    let output = "";
+    const handle = this.executeStreaming(
+      payload,
+      (_stream, data) => {
+        output += data;
+      },
+      abortSignal
+    );
+    const result = await handle.result;
+    return { ...result, output: output || result.output };
+  }
+  executeStreaming(payload, onOutput, abortSignal) {
+    const p = payload;
+    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT;
+    let resolve;
+    const resultPromise = new Promise((r) => {
+      resolve = r;
+    });
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve?.(result);
+    };
+    if (abortSignal?.aborted) {
+      return {
+        result: Promise.resolve({
+          status: "cancelled",
+          error: "Execution aborted"
+        }),
+        cancel: () => {
+        }
+      };
+    }
+    const args = ["copilot", "prompt", "--prompt", p.prompt];
+    if (p.autopilot) {
+      args.push("--autopilot");
+    }
+    if (p.allowTools && p.allowTools.length > 0) {
+      args.push("--allow-tools", p.allowTools.join(","));
+    }
+    if (p.model) {
+      args.push("--model", p.model);
+    }
+    if (p.agent) {
+      args.push("--agent", p.agent);
+    }
+    if (p.timeout != null) {
+      args.push("--timeout", String(p.timeout));
+    }
+    const child = spawn2("serviceme", args, {
+      cwd: p.workspace,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+      settle({
+        status: "timeout",
+        error: `Copilot CLI execution timed out after ${timeout / 1e3}s`
+      });
+    }, timeout);
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    child.stdout.on("data", (chunk) => {
+      const data = chunk.toString();
+      stdoutBuf += data;
+      if (stdoutBuf.length > MAX_OUTPUT_BYTES)
+        stdoutBuf = stdoutBuf.slice(-MAX_OUTPUT_BYTES);
+      onOutput("stdout", data);
+    });
+    child.stderr.on("data", (chunk) => {
+      const data = chunk.toString();
+      stderrBuf += data;
+      if (stderrBuf.length > MAX_OUTPUT_BYTES)
+        stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES);
+      onOutput("stderr", data);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        settle({ status: "success", output: stdoutBuf || void 0 });
+      } else {
+        settle({
+          status: "failure",
+          output: stdoutBuf || void 0,
+          error: stderrBuf || `Process exited with code ${code}`
+        });
+      }
+    });
+    child.on("error", (err) => {
+      settle({ status: "failure", error: err.message });
+    });
+    const cancelFn = () => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+      settle({ status: "cancelled", error: "Execution cancelled" });
+    };
+    abortSignal?.addEventListener("abort", () => cancelFn(), { once: true });
+    return { result: resultPromise, cancel: cancelFn };
+  }
+};
+
+// src/scheduled-tasks/executors/HttpRequestExecutor.ts
+var DEFAULT_TIMEOUT2 = 3e4;
+var HttpRequestExecutor = class {
+  async execute(payload, abortSignal) {
+    const p = payload;
+    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT2;
+    const ac = new AbortController();
+    let _timedOut = false;
+    const timer = setTimeout(() => {
+      _timedOut = true;
+      ac.abort();
+    }, timeout);
+    if (abortSignal?.aborted) {
+      clearTimeout(timer);
+      return { status: "cancelled", error: "Execution aborted" };
+    }
+    let externalAbort = false;
+    abortSignal?.addEventListener(
+      "abort",
+      () => {
+        externalAbort = true;
+        clearTimeout(timer);
+        ac.abort();
+      },
+      { once: true }
+    );
+    try {
+      const response = await fetch(p.url, {
+        method: p.method,
+        headers: p.headers,
+        body: p.body,
+        signal: ac.signal
+      });
+      clearTimeout(timer);
+      const body = await response.text();
+      if (response.ok) {
+        return {
+          status: "success",
+          output: `${response.status} ${response.statusText}
+${body}`.trim()
+        };
+      }
+      return {
+        status: "failure",
+        error: `HTTP ${response.status} ${response.statusText}
+${body}`.trim()
+      };
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof Error && err.name === "AbortError") {
+        if (externalAbort) {
+          return { status: "cancelled", error: "Execution cancelled" };
+        }
+        return {
+          status: "timeout",
+          error: `HTTP request timed out after ${timeout / 1e3}s`
+        };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { status: "failure", error: message };
+    }
+  }
+};
+
+// src/scheduled-tasks/executors/ShellExecutor.ts
+import { spawn as spawn3 } from "child_process";
+var DEFAULT_TIMEOUT3 = 6e4;
+var MAX_OUTPUT_BYTES2 = 1024 * 1024;
+var ShellExecutor = class {
+  async execute(payload, abortSignal) {
+    let output = "";
+    const handle = this.executeStreaming(
+      payload,
+      (_stream, data) => {
+        output += data;
+      },
+      abortSignal
+    );
+    const result = await handle.result;
+    return { ...result, output: output || result.output };
+  }
+  executeStreaming(payload, onOutput, abortSignal) {
+    const p = payload;
+    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT3;
+    let resolve;
+    const resultPromise = new Promise((r) => {
+      resolve = r;
+    });
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve?.(result);
+    };
+    if (abortSignal?.aborted) {
+      return {
+        result: Promise.resolve({
+          status: "cancelled",
+          error: "Execution aborted"
+        }),
+        cancel: () => {
+        }
+      };
+    }
+    const child = spawn3("sh", ["-c", p.script], {
+      cwd: p.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+      settle({
+        status: "timeout",
+        error: `Shell execution timed out after ${timeout / 1e3}s`
+      });
+    }, timeout);
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    child.stdout.on("data", (chunk) => {
+      const data = chunk.toString();
+      stdoutBuf += data;
+      if (stdoutBuf.length > MAX_OUTPUT_BYTES2)
+        stdoutBuf = stdoutBuf.slice(-MAX_OUTPUT_BYTES2);
+      onOutput("stdout", data);
+    });
+    child.stderr.on("data", (chunk) => {
+      const data = chunk.toString();
+      stderrBuf += data;
+      if (stderrBuf.length > MAX_OUTPUT_BYTES2)
+        stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES2);
+      onOutput("stderr", data);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        settle({ status: "success", output: stdoutBuf || void 0 });
+      } else {
+        settle({
+          status: "failure",
+          output: stdoutBuf || void 0,
+          error: stderrBuf || `Process exited with code ${code}`
+        });
+      }
+    });
+    child.on("error", (err) => {
+      settle({ status: "failure", error: err.message });
+    });
+    const cancelFn = () => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+      settle({ status: "cancelled", error: "Execution cancelled" });
+    };
+    abortSignal?.addEventListener("abort", () => cancelFn(), { once: true });
+    return { result: resultPromise, cancel: cancelFn };
+  }
+};
+
+// src/scheduled-tasks/executors/types.ts
+function isStreamingTaskExecutor(executor) {
+  return "executeStreaming" in executor && typeof executor.executeStreaming === "function";
+}
+
+// src/scheduled-tasks/executors/index.ts
+var executors = {
+  shell: new ShellExecutor(),
+  http_request: new HttpRequestExecutor(),
+  github_copilot_cli: new GithubCopilotCliExecutor()
+};
+function getExecutor(taskType) {
+  return executors[taskType];
+}
+
+// src/scheduled-tasks/TaskConfigManager.ts
+import { randomUUID } from "crypto";
+import * as fs5 from "fs";
+import * as path5 from "path";
+var CONFIG_DIR3 = ".serviceme";
+var CONFIG_FILE = "scheduled-tasks.json";
+function emptyConfig() {
+  return { version: 1, tasks: [] };
+}
+var TaskConfigManager = class {
+  constructor(workspacePath) {
+    this.configPath = path5.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+  readConfig() {
+    if (!fs5.existsSync(this.configPath)) {
+      return emptyConfig();
+    }
+    const raw = fs5.readFileSync(this.configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  }
+  writeConfig(config) {
+    const dir = path5.dirname(this.configPath);
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
+    }
+    const tmp = `${this.configPath}.tmp`;
+    fs5.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+    fs5.renameSync(tmp, this.configPath);
+  }
+  listTasks() {
+    return this.readConfig().tasks;
+  }
+  getTask(id) {
+    return this.readConfig().tasks.find((t) => t.id === id);
+  }
+  getTaskByName(name) {
+    return this.readConfig().tasks.find((t) => t.name === name);
+  }
+  createTask(input) {
+    const config = this.readConfig();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id: randomUUID(),
+      name: input.name,
+      description: input.description,
+      enabled: input.enabled ?? true,
+      scheduleType: input.scheduleType,
+      schedule: input.schedule,
+      taskType: input.taskType,
+      payload: input.payload,
+      createdAt: now,
+      updatedAt: now
+    };
+    config.tasks.push(task);
+    this.writeConfig(config);
+    return task;
+  }
+  editTask(id, input) {
+    const config = this.readConfig();
+    const idx = config.tasks.findIndex((t) => t.id === id);
+    if (idx === -1) {
+      throw new Error(`Task '${id}' not found`);
+    }
+    const existing = config.tasks[idx];
+    if (!existing) {
+      throw new Error(`Task '${id}' not found`);
+    }
+    const updated = {
+      ...existing,
+      ...input.name !== void 0 && { name: input.name },
+      ...input.description !== void 0 && {
+        description: input.description
+      },
+      ...input.scheduleType !== void 0 && {
+        scheduleType: input.scheduleType
+      },
+      ...input.schedule !== void 0 && { schedule: input.schedule },
+      ...input.taskType !== void 0 && { taskType: input.taskType },
+      ...input.payload !== void 0 && { payload: input.payload },
+      ...input.enabled !== void 0 && { enabled: input.enabled },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    config.tasks[idx] = updated;
+    this.writeConfig(config);
+    return updated;
+  }
+  deleteTask(id) {
+    const config = this.readConfig();
+    const idx = config.tasks.findIndex((t) => t.id === id);
+    if (idx === -1) {
+      throw new Error(`Task '${id}' not found`);
+    }
+    const removed = config.tasks[idx];
+    if (!removed) {
+      throw new Error(`Task '${id}' not found`);
+    }
+    config.tasks.splice(idx, 1);
+    this.writeConfig(config);
+    return removed;
+  }
+  toggleTask(id, enabled) {
+    return this.editTask(id, { enabled });
+  }
+};
+
+// src/scheduled-tasks/TaskLogManager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs6 from "fs";
+import * as path6 from "path";
+var CONFIG_DIR4 = ".serviceme";
+var LOG_FILE2 = "scheduled-tasks-log.json";
+var MAX_LOGS = 200;
+function emptyLogFile() {
+  return { logs: [] };
+}
+function isValidLogEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const e = entry;
+  return typeof e.id === "string" && typeof e.taskId === "string" && typeof e.taskName === "string" && typeof e.startedAt === "string" && typeof e.finishedAt === "string" && typeof e.status === "string";
+}
+function validateAndRepairLogFile(raw) {
+  if (!raw || typeof raw !== "object") {
+    return emptyLogFile();
+  }
+  const file = raw;
+  if (!Array.isArray(file.logs)) {
+    return emptyLogFile();
+  }
+  const validLogs = file.logs.filter(isValidLogEntry);
+  return { logs: validLogs };
+}
+var TaskLogManager = class {
+  constructor(workspacePath) {
+    this.logPath = path6.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+  readLogFile() {
+    if (!fs6.existsSync(this.logPath)) {
+      return emptyLogFile();
+    }
+    try {
+      const raw = fs6.readFileSync(this.logPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const file = validateAndRepairLogFile(parsed);
+      if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.logs) || parsed.logs.length !== file.logs.length) {
+        this.writeLogFile(file);
+      }
+      return file;
+    } catch {
+      this.backupCorruptedFile();
+      const fresh = emptyLogFile();
+      this.writeLogFile(fresh);
+      return fresh;
+    }
+  }
+  backupCorruptedFile() {
+    try {
+      if (fs6.existsSync(this.logPath)) {
+        const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
+        fs6.copyFileSync(this.logPath, backupPath);
+      }
+    } catch {
+    }
+  }
+  writeLogFile(file) {
+    const dir = path6.dirname(this.logPath);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
+    }
+    const tmp = `${this.logPath}.tmp`;
+    fs6.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+    fs6.renameSync(tmp, this.logPath);
+  }
+  appendLog(input) {
+    const file = this.readLogFile();
+    const log = {
+      id: randomUUID2(),
+      taskId: input.taskId,
+      taskName: input.taskName,
+      startedAt: input.startedAt,
+      finishedAt: input.finishedAt,
+      status: input.status,
+      output: input.output,
+      error: input.error
+    };
+    file.logs.push(log);
+    if (file.logs.length > MAX_LOGS) {
+      file.logs = file.logs.slice(file.logs.length - MAX_LOGS);
+    }
+    this.writeLogFile(file);
+    return log;
+  }
+  getLogs(options) {
+    const file = this.readLogFile();
+    let logs = file.logs;
+    if (options?.taskId) {
+      logs = logs.filter((l) => l.taskId === options.taskId);
+    }
+    const total = logs.length;
+    logs = logs.slice().reverse();
+    if (options?.limit && options.limit > 0) {
+      logs = logs.slice(0, options.limit);
+    }
+    return { logs, total };
+  }
+  clearLogs(taskId) {
+    const file = this.readLogFile();
+    const before = file.logs.length;
+    if (taskId) {
+      file.logs = file.logs.filter((l) => l.taskId !== taskId);
+    } else {
+      file.logs = [];
+    }
+    this.writeLogFile(file);
+    return before - file.logs.length;
+  }
+};
+
+// src/scheduled-tasks/daemon/SchedulerDaemon.ts
+var TICK_INTERVAL = 1e3;
+var MIN_SCHEDULE_INTERVAL = 1e3;
+var SchedulerDaemon = class {
+  constructor(workspacePath) {
+    this.tickTimer = null;
+    this.watcher = null;
+    this.running = false;
+    this.startTime = 0;
+    // Track last execution time and running state per task
+    this.lastRun = /* @__PURE__ */ new Map();
+    this.taskRunning = /* @__PURE__ */ new Set();
+    this.workspacePath = workspacePath;
+    this.configManager = new TaskConfigManager(workspacePath);
+    this.logManager = new TaskLogManager(workspacePath);
+    this.pidManager = new PidManager(workspacePath);
+    this.logger = new DaemonLogger(workspacePath);
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.startTime = Date.now();
+    this.pidManager.writePid(process.pid);
+    this.logger.log("info", `Scheduler daemon started (PID: ${process.pid})`);
+    this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL);
+    this.setupConfigWatch();
+    process.on("SIGTERM", () => this.stop());
+    process.on("SIGINT", () => this.stop());
+  }
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.pidManager.removePid();
+    this.logger.log("info", "Scheduler daemon stopped");
+    process.exit(0);
+  }
+  setupConfigWatch() {
+    const configPath = this.configManager.getConfigPath();
+    const dir = configPath.substring(0, configPath.lastIndexOf("/"));
+    try {
+      if (fs7.existsSync(dir)) {
+        this.watcher = fs7.watch(dir, (_eventType, filename) => {
+          if (filename === "scheduled-tasks.json") {
+            this.logger.log("info", "Config file changed, reconciling...");
+          }
+        });
+      }
+    } catch {
+      this.logger.log("warn", "Could not watch config directory");
+    }
+  }
+  tick() {
+    const config = this.configManager.readConfig();
+    const now = Date.now();
+    for (const task of config.tasks) {
+      if (!task.enabled) continue;
+      if (this.taskRunning.has(task.id)) continue;
+      const lastExec = this.lastRun.get(task.id) ?? 0;
+      if (this.shouldRun(task, lastExec, now)) {
+        this.executeTask(task, now);
+      }
+    }
+  }
+  shouldRun(task, lastExec, now) {
+    if (task.scheduleType === "interval") {
+      const intervalMs = parseIntervalMs(task.schedule);
+      if (intervalMs < MIN_SCHEDULE_INTERVAL) return false;
+      return now - lastExec >= intervalMs;
+    }
+    if (task.scheduleType === "cron") {
+      if (now - lastExec < 6e4) return false;
+      return matchesCron(task.schedule, new Date(now));
+    }
+    return false;
+  }
+  async executeTask(task, now) {
+    this.taskRunning.add(task.id);
+    this.lastRun.set(task.id, now);
+    const startedAt = new Date(now).toISOString();
+    this.logger.log("info", `Executing task: ${task.name} (${task.id})`);
+    try {
+      const executor = getExecutor(task.taskType);
+      const result = await executor.execute(task.payload);
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.logManager.appendLog({
+        taskId: task.id,
+        taskName: task.name,
+        startedAt,
+        finishedAt,
+        status: result.status === "running" ? "failure" : result.status,
+        output: result.output,
+        error: result.error
+      });
+      this.logger.log("info", `Task ${task.name} completed: ${result.status}`);
+    } catch (err) {
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const message = err instanceof Error ? err.message : String(err);
+      this.logManager.appendLog({
+        taskId: task.id,
+        taskName: task.name,
+        startedAt,
+        finishedAt,
+        status: "failure",
+        error: message
+      });
+      this.logger.log("error", `Task ${task.name} failed: ${message}`);
+    } finally {
+      this.taskRunning.delete(task.id);
+    }
+  }
+  getStatus() {
+    const config = this.configManager.readConfig();
+    return {
+      running: this.running,
+      pid: process.pid,
+      uptimeSeconds: this.running ? Math.floor((Date.now() - this.startTime) / 1e3) : null,
+      tasksRegistered: config.tasks.length,
+      tasksEnabled: config.tasks.filter((t) => t.enabled).length,
+      workspacePath: this.workspacePath,
+      pidFile: this.pidManager.getPidPath()
+    };
+  }
+};
+function parseIntervalMs(schedule) {
+  const match = /^every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?$/i.exec(schedule);
+  if (!match) return 0;
+  const [, numStr, unit] = match;
+  const num = Number.parseInt(numStr ?? "0", 10);
+  switch (unit?.toLowerCase()) {
+    case "s":
+    case "sec":
+      return num * 1e3;
+    case "m":
+    case "min":
+      return num * 60 * 1e3;
+    case "h":
+    case "hr":
+      return num * 60 * 60 * 1e3;
+    case "d":
+    case "day":
+      return num * 24 * 60 * 60 * 1e3;
+    default:
+      return 0;
+  }
+}
+function matchesCron(expression, date) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length < 5) return false;
+  const [minPart, hourPart, dayPart, monthPart, weekdayPart] = parts;
+  if (!minPart || !hourPart || !dayPart || !monthPart || !weekdayPart)
+    return false;
+  return matchCronField(minPart, date.getMinutes()) && matchCronField(hourPart, date.getHours()) && matchCronField(dayPart, date.getDate()) && matchCronField(monthPart, date.getMonth() + 1) && matchCronField(weekdayPart, date.getDay());
+}
+function matchCronField(field, value) {
+  if (field === "*") return true;
+  if (field.startsWith("*/")) {
+    const step = Number.parseInt(field.slice(2), 10);
+    return step > 0 && value % step === 0;
+  }
+  const values = field.split(",");
+  return values.some((v) => Number.parseInt(v, 10) === value);
+}
+
+// src/scheduled-tasks/TaskExecutionEngine.ts
+var TaskExecutionEngine = class {
+  constructor(getExecutor2) {
+    this.getExecutor = getExecutor2;
+    this.running = /* @__PURE__ */ new Map();
+    this.taskExecutions = /* @__PURE__ */ new Map();
+    this.listener = null;
+  }
+  setListener(listener) {
+    this.listener = listener;
+  }
+  async execute(snapshot) {
+    const policy = snapshot.concurrencyPolicy ?? "reject";
+    if (policy === "reject") {
+      const existingIds = this.taskExecutions.get(snapshot.taskId);
+      if (existingIds && existingIds.size > 0) {
+        throw new Error(
+          `TASK_ALREADY_RUNNING: Task ${snapshot.taskId} is already running`
+        );
+      }
+    }
+    const executor = this.getExecutor(snapshot.type);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (!this.taskExecutions.has(snapshot.taskId)) {
+      this.taskExecutions.set(snapshot.taskId, /* @__PURE__ */ new Set());
+    }
+    this.taskExecutions.get(snapshot.taskId)?.add(snapshot.executionId);
+    const ac = new AbortController();
+    const runningExec = {
+      executionId: snapshot.executionId,
+      taskId: snapshot.taskId,
+      startedAt,
+      cancel: () => ac.abort()
+    };
+    this.running.set(snapshot.executionId, runningExec);
+    this.listener?.onStarted({
+      executionId: snapshot.executionId,
+      taskId: snapshot.taskId,
+      startedAt
+    });
+    try {
+      let result;
+      if (isStreamingTaskExecutor(executor)) {
+        const handle = executor.executeStreaming(
+          snapshot.payload,
+          (stream, data) => {
+            this.listener?.onOutput({
+              executionId: snapshot.executionId,
+              stream,
+              data
+            });
+          },
+          ac.signal
+        );
+        runningExec.cancel = () => {
+          handle.cancel();
+          ac.abort();
+        };
+        result = await handle.result;
+      } else {
+        result = await executor.execute(snapshot.payload, ac.signal);
+      }
+      const log = {
+        id: snapshot.executionId,
+        taskId: snapshot.taskId,
+        taskName: snapshot.name,
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: result.status === "running" ? "failure" : result.status,
+        output: result.output,
+        error: result.error
+      };
+      switch (log.status) {
+        case "success":
+          this.listener?.onCompleted({
+            executionId: snapshot.executionId,
+            log
+          });
+          break;
+        case "cancelled":
+          this.listener?.onCancelled({
+            executionId: snapshot.executionId,
+            log
+          });
+          break;
+        case "timeout":
+          this.listener?.onFailed({
+            executionId: snapshot.executionId,
+            status: "timeout",
+            reason: "timeout",
+            log
+          });
+          break;
+        default:
+          this.listener?.onFailed({
+            executionId: snapshot.executionId,
+            status: "failure",
+            reason: "error",
+            log
+          });
+          break;
+      }
+    } catch (err) {
+      const log = {
+        id: snapshot.executionId,
+        taskId: snapshot.taskId,
+        taskName: snapshot.name,
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: ac.signal.aborted ? "cancelled" : "failure",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      if (ac.signal.aborted) {
+        this.listener?.onCancelled({
+          executionId: snapshot.executionId,
+          log
+        });
+      } else {
+        this.listener?.onFailed({
+          executionId: snapshot.executionId,
+          status: "failure",
+          reason: "error",
+          log
+        });
+      }
+    } finally {
+      this.running.delete(snapshot.executionId);
+      const taskExecIds = this.taskExecutions.get(snapshot.taskId);
+      if (taskExecIds) {
+        taskExecIds.delete(snapshot.executionId);
+        if (taskExecIds.size === 0) {
+          this.taskExecutions.delete(snapshot.taskId);
+        }
+      }
+    }
+  }
+  cancel(executionId) {
+    const exec = this.running.get(executionId);
+    if (!exec) return false;
+    exec.cancel();
+    return true;
+  }
+  listRunning() {
+    return Array.from(this.running.values()).map((e) => ({
+      executionId: e.executionId,
+      taskId: e.taskId,
+      startedAt: e.startedAt
+    }));
+  }
+  dispose() {
+    for (const exec of this.running.values()) {
+      exec.cancel();
+    }
+    this.running.clear();
+    this.taskExecutions.clear();
+  }
+};
 export {
+  DaemonLogger,
   EnvironmentInspector,
+  GithubCopilotCliExecutor,
+  HttpRequestExecutor,
   ImageTools,
-  OpenCodeManager,
+  PidManager,
   ProjectTools,
+  SchedulerDaemon,
+  ShellExecutor,
+  TaskConfigManager,
+  TaskExecutionEngine,
+  TaskLogManager,
+  copilotDoctor,
+  copilotPrompt,
   createConsoleLogger,
+  createCopilotAuthRequiredError,
+  createCopilotNotInstalledError,
   createImageTools,
   createJsonTools,
   createProjectTools,
+  getExecutor,
+  isCopilotAuthenticated,
+  isStreamingTaskExecutor,
+  matchesCron,
   moveFiles,
   noopLogger,
+  parseIntervalMs,
   unzipFile
 };