@serviceme/devtools-core 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -39,7 +39,8 @@ async function runCommand(command, options = {}) {
       cwd: options.cwd,
       env: options.env,
       shell: options.shell,
-      stdio: "pipe"
+      stdio: "pipe",
+      windowsHide: true
     });
     let stdout = "";
     let stderr = "";
@@ -243,8 +244,14 @@ import {
   createServicemeError as createServicemeError3,
   KNOWN_ENVIRONMENT_TOOLS
 } from "@serviceme/devtools-protocol";
-var TOOL_CHECK_TIMEOUT_MS = 5e3;
+var DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
+var TOOL_CHECK_TIMEOUT_MS = {
+  nuget: 12e3,
+  nvm: 8e3,
+  dotnet: 8e3
+};
 var ERROR_CODE_NOT_FOUND = 127;
+var ERROR_CODE_TIMEOUT = "ETIMEDOUT";
 var EnvironmentInspector = class {
   async checkEnvironment() {
     const results = await Promise.all(
@@ -281,19 +288,18 @@ var EnvironmentInspector = class {
       const isWindows = process.platform === "win32";
       const result = await runCommand(isWindows ? "where" : "which", {
         args: [toolName],
-        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+        timeoutMs: this.getToolTimeout(toolName)
       });
-      return result.stdout.trim().split("\n")[0];
+      return result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
     } catch {
       return void 0;
     }
   }
   async getToolVersion(toolName) {
-    const command = this.getVersionCommand(toolName);
-    const isWindows = process.platform === "win32";
-    const result = await runCommand(isWindows ? "cmd.exe" : "/bin/bash", {
-      args: isWindows ? ["/c", command] : ["-lc", command],
-      timeoutMs: TOOL_CHECK_TIMEOUT_MS
+    const invocation = this.getVersionInvocation(toolName);
+    const result = await runCommand(invocation.command, {
+      args: invocation.args,
+      timeoutMs: this.getToolTimeout(toolName)
     });
     return this.parseVersion(toolName, result.stdout || result.stderr);
   }
@@ -302,7 +308,7 @@ var EnvironmentInspector = class {
       try {
         const result = await runCommand("cmd.exe", {
           args: ["/c", "nvm version"],
-          timeoutMs: TOOL_CHECK_TIMEOUT_MS
+          timeoutMs: this.getToolTimeout("nvm")
         });
         return {
           installed: true,
@@ -322,7 +328,7 @@ var EnvironmentInspector = class {
           "-lc",
           'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; nvm --version'
         ],
-        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+        timeoutMs: this.getToolTimeout("nvm")
       });
       return {
         installed: true,
@@ -347,7 +353,7 @@ var EnvironmentInspector = class {
     try {
       const result = await runCommand("dotnet", {
         args: ["nuget", "list", "source"],
-        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+        timeoutMs: this.getToolTimeout("nuget")
       });
       const privateSourceUrl = "http://192.168.20.209:10010/nuget";
       if (result.stdout.includes(privateSourceUrl)) {
@@ -365,17 +371,28 @@ var EnvironmentInspector = class {
       return this.handleToolCheckError(error);
     }
   }
-  getVersionCommand(toolName) {
+  getVersionInvocation(toolName) {
+    const isWindows = process.platform === "win32";
+    if (isWindows && ["npm", "pnpm", "nrm"].includes(toolName)) {
+      return {
+        command: "cmd.exe",
+        args: ["/d", "/s", "/c", `${toolName} --version`]
+      };
+    }
     const commands = {
-      git: "git --version",
-      node: "node --version",
-      npm: "npm --version",
-      pnpm: "pnpm --version",
-      nvm: "nvm --version",
-      nrm: "nrm --version",
-      dotnet: "dotnet --version"
+      git: { command: "git", args: ["--version"] },
+      node: { command: "node", args: ["--version"] },
+      npm: { command: "npm", args: ["--version"] },
+      pnpm: { command: "pnpm", args: ["--version"] },
+      nvm: { command: "nvm", args: ["--version"] },
+      nrm: { command: "nrm", args: ["--version"] },
+      rtk: { command: "rtk", args: ["--version"] },
+      dotnet: { command: "dotnet", args: ["--version"] }
     };
-    return commands[toolName] || `${toolName} --version`;
+    return commands[toolName] || { command: toolName, args: ["--version"] };
+  }
+  getToolTimeout(toolName) {
+    return TOOL_CHECK_TIMEOUT_MS[toolName] ?? DEFAULT_TOOL_CHECK_TIMEOUT_MS;
   }
   parseVersion(toolName, output) {
     const cleaned = output.trim();
@@ -402,10 +419,11 @@ var EnvironmentInspector = class {
     const execError = error;
     const message = execError.message || String(error);
     const code = execError.code;
-    const isNotFound = message.includes("command not found") || message.includes("not recognized") || code === ERROR_CODE_NOT_FOUND;
+    const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || code === "ENOENT" || code === ERROR_CODE_NOT_FOUND;
+    const isTimeout = code === ERROR_CODE_TIMEOUT || message.toLowerCase().includes("timed out");
     return {
       installed: false,
-      error: isNotFound ? "Not installed" : message
+      error: isNotFound ? "Not installed" : isTimeout ? "Check timed out" : message
     };
   }
 };
@@ -1081,12 +1099,75 @@ var PidManager = class {
 };
 
 // src/scheduled-tasks/daemon/SchedulerDaemon.ts
-import * as fs7 from "fs";
+import * as fs9 from "fs";
+import * as os from "os";
 
 // src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
 import { spawn as spawn2 } from "child_process";
-var DEFAULT_TIMEOUT = 3e5;
+import * as fs5 from "fs";
+
+// src/scheduled-tasks/executors/timeout.ts
+function resolveConfiguredTimeoutMs(timeoutSeconds, defaultTimeoutMs) {
+  if (timeoutSeconds === 0) {
+    return void 0;
+  }
+  if (typeof timeoutSeconds !== "number" || !Number.isFinite(timeoutSeconds) || timeoutSeconds < 0) {
+    return defaultTimeoutMs;
+  }
+  return timeoutSeconds * 1e3;
+}
+
+// src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts
 var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS2 = 3e5;
+function redactArgs(args) {
+  const redacted = [];
+  let redactNext = false;
+  for (const arg of args) {
+    if (redactNext) {
+      redacted.push("<redacted>");
+      redactNext = false;
+      continue;
+    }
+    redacted.push(arg);
+    if (arg === "--prompt") {
+      redactNext = true;
+    }
+  }
+  return redacted;
+}
+function writeDiagnostic(message) {
+  const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
+  if (logPath) {
+    fs5.appendFileSync(logPath, message);
+    return;
+  }
+  process.stderr.write(message);
+}
+function resolveGithubCopilotCliExecution(payload) {
+  const args = ["copilot", "prompt", "--prompt", payload.prompt];
+  if (payload.autopilot) {
+    args.push("--autopilot");
+  }
+  if (payload.allowTools && payload.allowTools.length > 0) {
+    args.push("--allow-tools", payload.allowTools.join(","));
+  }
+  if (payload.model) {
+    args.push("--model", payload.model);
+  }
+  if (payload.agent) {
+    args.push("--agent", payload.agent);
+  }
+  args.push("--timeout", String(payload.timeout ?? 0));
+  return {
+    command: "serviceme",
+    args,
+    cwd: payload.workspace,
+    timeoutMs: resolveConfiguredTimeoutMs(payload.timeout, DEFAULT_TIMEOUT_MS2),
+    diagnosticArgs: redactArgs(args),
+    promptLen: payload.prompt.length
+  };
+}
 var GithubCopilotCliExecutor = class {
   async execute(payload, abortSignal) {
     const authenticated = await isCopilotAuthenticated();
@@ -1109,7 +1190,7 @@ var GithubCopilotCliExecutor = class {
   }
   executeStreaming(payload, onOutput, abortSignal) {
     const p = payload;
-    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT;
+    const execution = resolveGithubCopilotCliExecution(p);
     let resolve;
     const resultPromise = new Promise((r) => {
       resolve = r;
@@ -1118,7 +1199,7 @@ var GithubCopilotCliExecutor = class {
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
       resolve?.(result);
     };
     if (abortSignal?.aborted) {
@@ -1131,36 +1212,32 @@ var GithubCopilotCliExecutor = class {
         }
       };
     }
-    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"]
+    writeDiagnostic(
+      `[GithubCopilotCliExecutor] spawn: command=${execution.command}, args=${JSON.stringify(execution.diagnosticArgs)}, promptLen=${execution.promptLen}, cwd=${execution.cwd ?? "(default)"}, platform=${process.platform}, windowsHide=true, pid=${process.pid}
+`
+    );
+    const child = spawn2(execution.command, execution.args, {
+      cwd: execution.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
-    const timer = setTimeout(() => {
+    if (child.pid) {
+      writeDiagnostic(
+        `[GithubCopilotCliExecutor] spawned child PID=${child.pid}
+`
+      );
+    }
+    const timeoutMs = execution.timeoutMs;
+    const timer = timeoutMs != null ? 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`
+        error: `Copilot CLI execution timed out after ${timeoutMs / 1e3}s`
       });
-    }, timeout);
+    }, timeoutMs) : void 0;
     let stdoutBuf = "";
     let stderrBuf = "";
     child.stdout.on("data", (chunk) => {
@@ -1204,19 +1281,19 @@ var GithubCopilotCliExecutor = class {
 };
 
 // src/scheduled-tasks/executors/HttpRequestExecutor.ts
-var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_TIMEOUT_MS3 = 3e4;
 var HttpRequestExecutor = class {
   async execute(payload, abortSignal) {
     const p = payload;
-    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT2;
+    const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS3);
     const ac = new AbortController();
-    let _timedOut = false;
-    const timer = setTimeout(() => {
-      _timedOut = true;
+    let timedOut = false;
+    const timer = timeoutMs != null ? setTimeout(() => {
+      timedOut = true;
       ac.abort();
-    }, timeout);
+    }, timeoutMs) : void 0;
     if (abortSignal?.aborted) {
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
       return { status: "cancelled", error: "Execution aborted" };
     }
     let externalAbort = false;
@@ -1224,7 +1301,7 @@ var HttpRequestExecutor = class {
       "abort",
       () => {
         externalAbort = true;
-        clearTimeout(timer);
+        if (timer) clearTimeout(timer);
         ac.abort();
       },
       { once: true }
@@ -1236,7 +1313,7 @@ var HttpRequestExecutor = class {
         body: p.body,
         signal: ac.signal
       });
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
       const body = await response.text();
       if (response.ok) {
         return {
@@ -1251,14 +1328,17 @@ ${body}`.trim()
 ${body}`.trim()
       };
     } catch (err) {
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
       if (err instanceof Error && err.name === "AbortError") {
         if (externalAbort) {
           return { status: "cancelled", error: "Execution cancelled" };
         }
+        if (!timedOut || timeoutMs == null) {
+          return { status: "failure", error: err.message };
+        }
         return {
           status: "timeout",
-          error: `HTTP request timed out after ${timeout / 1e3}s`
+          error: `HTTP request timed out after ${timeoutMs / 1e3}s`
         };
       }
       const message = err instanceof Error ? err.message : String(err);
@@ -1269,8 +1349,82 @@ ${body}`.trim()
 
 // src/scheduled-tasks/executors/ShellExecutor.ts
 import { spawn as spawn3 } from "child_process";
-var DEFAULT_TIMEOUT3 = 6e4;
+import * as fs6 from "fs";
+import * as path5 from "path";
 var MAX_OUTPUT_BYTES2 = 1024 * 1024;
+var DEFAULT_TIMEOUT_MS4 = 6e4;
+var POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
+function resolveShellExecution(script, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const fileExists = options.fileExists ?? fs6.existsSync;
+  if (platform === "win32") {
+    const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
+    if (posixShell) {
+      return {
+        command: posixShell,
+        args: ["-s"],
+        stdinScript: script,
+        outputEncoding: "utf8",
+        shellKind: "posix"
+      };
+    }
+    return {
+      command: env.ComSpec ?? env.COMSPEC ?? "cmd.exe",
+      args: ["/d", "/s", "/c", script],
+      outputEncoding: "utf8",
+      shellKind: "cmd"
+    };
+  }
+  return {
+    command: "sh",
+    args: ["-s"],
+    stdinScript: script,
+    outputEncoding: "utf8",
+    shellKind: "posix"
+  };
+}
+function usesPosixShellSyntax(script) {
+  return /\$\([^)]*\)|`[^`]*`/.test(script);
+}
+function findWindowsPosixShell(env, fileExists) {
+  const explicitShell = env.SERVICEME_POSIX_SHELL;
+  if (explicitShell && fileExists(explicitShell)) {
+    return explicitShell;
+  }
+  const knownGitBashPaths = [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe"
+  ];
+  for (const candidate of knownGitBashPaths) {
+    if (fileExists(candidate)) return candidate;
+  }
+  const pathValue = env.Path ?? env.PATH ?? "";
+  for (const dir of pathValue.split(path5.win32.delimiter)) {
+    if (!dir) continue;
+    for (const executable of POSIX_SHELL_CANDIDATES) {
+      const candidate = path5.win32.join(dir, executable);
+      if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function isWindowsWslLauncher(candidate) {
+  const normalized = path5.win32.normalize(candidate).toLowerCase();
+  return normalized.endsWith("\\windows\\system32\\bash.exe") || normalized.endsWith("\\windows\\syswow64\\bash.exe");
+}
+function writeDiagnostic2(message) {
+  const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
+  if (logPath) {
+    fs6.appendFileSync(logPath, message);
+    return;
+  }
+  process.stderr.write(message);
+}
 var ShellExecutor = class {
   async execute(payload, abortSignal) {
     let output = "";
@@ -1286,7 +1440,7 @@ var ShellExecutor = class {
   }
   executeStreaming(payload, onOutput, abortSignal) {
     const p = payload;
-    const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT3;
+    const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS4);
     let resolve;
     const resultPromise = new Promise((r) => {
       resolve = r;
@@ -1295,7 +1449,7 @@ var ShellExecutor = class {
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      clearTimeout(timer);
+      if (timer) clearTimeout(timer);
       resolve?.(result);
     };
     if (abortSignal?.aborted) {
@@ -1308,37 +1462,65 @@ var ShellExecutor = class {
         }
       };
     }
-    const child = spawn3("sh", ["-c", p.script], {
+    const shellExecution = resolveShellExecution(p.script);
+    const spawnOpts = {
       cwd: p.cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const timer = setTimeout(() => {
+      stdio: [shellExecution.stdinScript ? "pipe" : "ignore", "pipe", "pipe"],
+      windowsHide: true
+    };
+    writeDiagnostic2(
+      `[ShellExecutor] spawn:
+  platform=${process.platform}
+  shell=${shellExecution.shellKind}
+  command=${shellExecution.command}
+  args=${JSON.stringify(shellExecution.args.filter((a) => a !== p.script))}
+  stdin=${shellExecution.stdinScript ? "true" : "false"}
+  cwd=${p.cwd ?? "(default)"}
+  timeout=${timeoutMs != null ? `${timeoutMs}ms` : "unlimited"}
+  scriptLen=${p.script.length}
+  windowsHide=true
+  daemonPid=${process.pid}
+`
+    );
+    const child = spawn3(shellExecution.command, shellExecution.args, spawnOpts);
+    if (shellExecution.stdinScript && child.stdin) {
+      child.stdin.end(shellExecution.stdinScript);
+    }
+    if (child.pid) {
+      writeDiagnostic2(`[ShellExecutor] spawned child PID=${child.pid}
+`);
+    }
+    const timer = timeoutMs != null ? setTimeout(() => {
       child.kill("SIGTERM");
       setTimeout(() => {
         if (!child.killed) child.kill("SIGKILL");
       }, 5e3);
       settle({
         status: "timeout",
-        error: `Shell execution timed out after ${timeout / 1e3}s`
+        error: `Shell execution timed out after ${timeoutMs / 1e3}s`
       });
-    }, timeout);
+    }, timeoutMs) : void 0;
     let stdoutBuf = "";
     let stderrBuf = "";
-    child.stdout.on("data", (chunk) => {
-      const data = chunk.toString();
+    child.stdout?.on("data", (chunk) => {
+      const data = chunk.toString(shellExecution.outputEncoding);
       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();
+    child.stderr?.on("data", (chunk) => {
+      const data = chunk.toString(shellExecution.outputEncoding);
       stderrBuf += data;
       if (stderrBuf.length > MAX_OUTPUT_BYTES2)
         stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES2);
       onOutput("stderr", data);
     });
     child.on("close", (code) => {
+      writeDiagnostic2(
+        `[ShellExecutor] child PID=${child.pid} exited: code=${code}
+`
+      );
       if (code === 0) {
         settle({ status: "success", output: stdoutBuf || void 0 });
       } else {
@@ -1385,36 +1567,65 @@ function getExecutor(taskType) {
 
 // src/scheduled-tasks/TaskConfigManager.ts
 import { randomUUID } from "crypto";
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
+import { createServicemeError as createServicemeError7 } from "@serviceme/devtools-protocol";
 var CONFIG_DIR3 = ".serviceme";
 var CONFIG_FILE = "scheduled-tasks.json";
 function emptyConfig() {
   return { version: 1, tasks: [] };
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireNonEmptyString(payload, field, taskType) {
+  if (!isRecord(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
+    throw createServicemeError7(
+      "invalid_payload",
+      `${taskType} payload ${field} is required`
+    );
+  }
+}
+function validateTaskPayload(taskType, payload) {
+  switch (taskType) {
+    case "command":
+      requireNonEmptyString(payload, "command", taskType);
+      return;
+    case "shell":
+      requireNonEmptyString(payload, "script", taskType);
+      return;
+    case "http_request":
+      requireNonEmptyString(payload, "url", taskType);
+      requireNonEmptyString(payload, "method", taskType);
+      return;
+    case "github_copilot_cli":
+      requireNonEmptyString(payload, "prompt", taskType);
+      return;
+  }
+}
 var TaskConfigManager = class {
   constructor(workspacePath) {
-    this.configPath = path5.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
+    this.configPath = path6.join(workspacePath, CONFIG_DIR3, CONFIG_FILE);
   }
   getConfigPath() {
     return this.configPath;
   }
   readConfig() {
-    if (!fs5.existsSync(this.configPath)) {
+    if (!fs7.existsSync(this.configPath)) {
       return emptyConfig();
     }
-    const raw = fs5.readFileSync(this.configPath, "utf-8");
+    const raw = fs7.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 dir = path6.dirname(this.configPath);
+    if (!fs7.existsSync(dir)) {
+      fs7.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.configPath}.tmp`;
-    fs5.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
-    fs5.renameSync(tmp, this.configPath);
+    fs7.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+    fs7.renameSync(tmp, this.configPath);
   }
   listTasks() {
     return this.readConfig().tasks;
@@ -1426,6 +1637,7 @@ var TaskConfigManager = class {
     return this.readConfig().tasks.find((t) => t.name === name);
   }
   createTask(input) {
+    validateTaskPayload(input.taskType, input.payload);
     const config = this.readConfig();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const task = {
@@ -1454,6 +1666,9 @@ var TaskConfigManager = class {
     if (!existing) {
       throw new Error(`Task '${id}' not found`);
     }
+    const nextTaskType = input.taskType ?? existing.taskType;
+    const nextPayload = input.payload ?? existing.payload;
+    validateTaskPayload(nextTaskType, nextPayload);
     const updated = {
       ...existing,
       ...input.name !== void 0 && { name: input.name },
@@ -1492,10 +1707,197 @@ var TaskConfigManager = class {
   }
 };
 
+// src/scheduled-tasks/TaskExecutionEngine.ts
+function hasNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function resolveTaskExecutionPayload(taskType, payload, workspacePath) {
+  if (!hasNonEmptyString(workspacePath)) {
+    return payload;
+  }
+  if (taskType === "shell") {
+    const shellPayload = payload;
+    if (hasNonEmptyString(shellPayload.cwd)) {
+      return shellPayload;
+    }
+    return { ...shellPayload, cwd: workspacePath };
+  }
+  if (taskType === "github_copilot_cli") {
+    const copilotPayload = payload;
+    if (hasNonEmptyString(copilotPayload.workspace)) {
+      return copilotPayload;
+    }
+    return { ...copilotPayload, workspace: workspacePath };
+  }
+  return payload;
+}
+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 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 {
+      const executionPayload = resolveTaskExecutionPayload(
+        snapshot.type,
+        snapshot.payload,
+        snapshot.workspacePath
+      );
+      validateTaskPayload(snapshot.type, executionPayload);
+      const executor = this.getExecutor(snapshot.type);
+      let result;
+      if (isStreamingTaskExecutor(executor)) {
+        const handle = executor.executeStreaming(
+          executionPayload,
+          (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(executionPayload, 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();
+  }
+};
+
 // src/scheduled-tasks/TaskLogManager.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 var CONFIG_DIR4 = ".serviceme";
 var LOG_FILE2 = "scheduled-tasks-log.json";
 var MAX_LOGS = 200;
@@ -1520,17 +1922,17 @@ function validateAndRepairLogFile(raw) {
 }
 var TaskLogManager = class {
   constructor(workspacePath) {
-    this.logPath = path6.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
+    this.logPath = path7.join(workspacePath, CONFIG_DIR4, LOG_FILE2);
   }
   getLogPath() {
     return this.logPath;
   }
   readLogFile() {
-    if (!fs6.existsSync(this.logPath)) {
+    if (!fs8.existsSync(this.logPath)) {
       return emptyLogFile();
     }
     try {
-      const raw = fs6.readFileSync(this.logPath, "utf-8");
+      const raw = fs8.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) {
@@ -1546,21 +1948,21 @@ var TaskLogManager = class {
   }
   backupCorruptedFile() {
     try {
-      if (fs6.existsSync(this.logPath)) {
+      if (fs8.existsSync(this.logPath)) {
         const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
-        fs6.copyFileSync(this.logPath, backupPath);
+        fs8.copyFileSync(this.logPath, backupPath);
       }
     } catch {
     }
   }
   writeLogFile(file) {
-    const dir = path6.dirname(this.logPath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(this.logPath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
     const tmp = `${this.logPath}.tmp`;
-    fs6.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
-    fs6.renameSync(tmp, this.logPath);
+    fs8.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+    fs8.renameSync(tmp, this.logPath);
   }
   appendLog(input) {
     const file = this.readLogFile();
@@ -1630,7 +2032,23 @@ var SchedulerDaemon = class {
     this.running = true;
     this.startTime = Date.now();
     this.pidManager.writePid(process.pid);
-    this.logger.log("info", `Scheduler daemon started (PID: ${process.pid})`);
+    const configPath = this.configManager.getConfigPath();
+    const logPath = this.logger.getLogPath();
+    this.logger.log("info", "=".repeat(60));
+    this.logger.log(
+      "info",
+      `Scheduler daemon started
+  PID:       ${process.pid}
+  Node:      ${process.version}
+  OS:        ${os.type()} ${os.release()} (${process.arch})
+  Platform:  ${process.platform}
+  Hostname:  ${os.hostname()}
+  User:      ${os.userInfo().username}
+  Workspace: ${this.workspacePath}
+  Config:    ${configPath}
+  LogPath:   ${logPath}
+  ExecPath:  ${process.execPath}`
+    );
     this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL);
     this.setupConfigWatch();
     process.on("SIGTERM", () => this.stop());
@@ -1655,8 +2073,8 @@ var SchedulerDaemon = class {
     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 (fs9.existsSync(dir)) {
+        this.watcher = fs9.watch(dir, (_eventType, filename) => {
           if (filename === "scheduled-tasks.json") {
             this.logger.log("info", "Config file changed, reconciling...");
           }
@@ -1672,7 +2090,11 @@ var SchedulerDaemon = class {
     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;
+      let lastExec = this.lastRun.get(task.id);
+      if (lastExec === void 0) {
+        this.lastRun.set(task.id, now);
+        lastExec = now;
+      }
       if (this.shouldRun(task, lastExec, now)) {
         this.executeTask(task, now);
       }
@@ -1694,11 +2116,25 @@ var SchedulerDaemon = class {
     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})`);
+    const startMs = Date.now();
+    this.logger.log(
+      "info",
+      `Executing task: ${task.name} (${task.id})
+  type:     ${task.taskType}
+  schedule: ${task.schedule} (${task.scheduleType})
+  enabled:  ${task.enabled}`
+    );
     try {
+      const executionPayload = resolveTaskExecutionPayload(
+        task.taskType,
+        task.payload,
+        this.workspacePath
+      );
+      validateTaskPayload(task.taskType, executionPayload);
       const executor = getExecutor(task.taskType);
-      const result = await executor.execute(task.payload);
+      const result = await executor.execute(executionPayload);
       const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const durationMs = Date.now() - startMs;
       this.logManager.appendLog({
         taskId: task.id,
         taskName: task.name,
@@ -1708,9 +2144,17 @@ var SchedulerDaemon = class {
         output: result.output,
         error: result.error
       });
-      this.logger.log("info", `Task ${task.name} completed: ${result.status}`);
+      const outputBytes = result.output ? Buffer.byteLength(result.output) : 0;
+      this.logger.log(
+        "info",
+        `Task completed: ${task.name} (${task.id})
+  status:   ${result.status}
+  duration: ${durationMs}ms
+  outputBytes: ${outputBytes}`
+      );
     } catch (err) {
       const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const durationMs = Date.now() - startMs;
       const message = err instanceof Error ? err.message : String(err);
       this.logManager.appendLog({
         taskId: task.id,
@@ -1720,7 +2164,12 @@ var SchedulerDaemon = class {
         status: "failure",
         error: message
       });
-      this.logger.log("error", `Task ${task.name} failed: ${message}`);
+      this.logger.log(
+        "error",
+        `Task failed: ${task.name} (${task.id})
+  duration: ${durationMs}ms
+  error:    ${message}`
+      );
     } finally {
       this.taskRunning.delete(task.id);
     }
@@ -1777,164 +2226,6 @@ function matchCronField(field, value) {
   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,
@@ -1963,5 +2254,7 @@ export {
   moveFiles,
   noopLogger,
   parseIntervalMs,
-  unzipFile
+  resolveTaskExecutionPayload,
+  unzipFile,
+  validateTaskPayload
 };