@serviceme/devtools-cli 0.0.6 → 0.1.2

package/dist/bridgeServer.js

@@ -5,8 +5,8 @@ var readline = require('readline');
 var child_process = require('child_process');
 require('fs/promises');
 require('path');
-var crypto = require('crypto');
 require('fs');
+require('crypto');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -7926,10 +7926,10 @@ var require_stringify = __commonJS({
       replacer = null;
       indent = EMPTY;
     };
-    var join4 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY;
+    var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + LF + gap : two ? two.trimRight() + LF + gap : EMPTY;
     var join_content = (inside, value, gap) => {
       const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-      return join4(comment, inside, gap);
+      return join8(comment, inside, gap);
     };
     var array_stringify = (value, gap) => {
       const deeper_gap = gap + indent;
@@ -7940,7 +7940,7 @@ var require_stringify = __commonJS({
         if (i !== 0) {
           inside += COMMA;
         }
-        const before = join4(
+        const before = join8(
           after_comma,
           process_comments(value, BEFORE(i), deeper_gap),
           deeper_gap
@@ -7950,7 +7950,7 @@ var require_stringify = __commonJS({
         inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
         after_comma = process_comments(value, AFTER(i), deeper_gap);
       }
-      inside += join4(
+      inside += join8(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -7975,7 +7975,7 @@ var require_stringify = __commonJS({
           inside += COMMA;
         }
         first = false;
-        const before = join4(
+        const before = join8(
           after_comma,
           process_comments(value, BEFORE(key), deeper_gap),
           deeper_gap
@@ -7985,7 +7985,7 @@ var require_stringify = __commonJS({
         after_comma = process_comments(value, AFTER(key), deeper_gap);
       };
       keys.forEach(iteratee);
-      inside += join4(
+      inside += join8(
         after_comma,
         process_comments(value, PREFIX_AFTER, deeper_gap),
         deeper_gap
@@ -8143,7 +8143,7 @@ var require_pend = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js"(exports$1) {
-    var fs3 = __require("fs");
+    var fs8 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -8168,7 +8168,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs3.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs8.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -8177,7 +8177,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs3.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs8.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -8198,7 +8198,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount > 0) return;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.autoClose) {
-        fs3.close(self.fd, onCloseDone);
+        fs8.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -8235,7 +8235,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
         var buffer = Buffer.allocUnsafe(toRead);
-        fs3.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs8.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -8282,7 +8282,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
-        fs3.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs8.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -8720,7 +8720,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js"(exports$1) {
-    var fs3 = __require("fs");
+    var fs8 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -8741,7 +8741,7 @@ var require_yauzl = __commonJS({
     exports$1.Entry = Entry;
     exports$1.LocalFileHeader = LocalFileHeader;
     exports$1.RandomAccessReader = RandomAccessReader;
-    function open2(path3, options2, callback) {
+    function open2(path7, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -8753,10 +8753,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs3.open(path3, "r", function(err, fd) {
+      fs8.open(path7, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs3.close(fd, defaultCallback);
+          if (err2) fs8.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -8773,7 +8773,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs3.fstat(fd, function(err, stats) {
+      fs8.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -9458,21 +9458,20 @@ var require_yauzl = __commonJS({
 });
 
 // ../../packages/serviceme-protocol/src/bridge.ts
-var SERVICEME_PROTOCOL_VERSION = 1;
+var SERVICEME_PROTOCOL_VERSION = 2;
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
+function isValidProtocolVersion(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= SERVICEME_PROTOCOL_VERSION;
+}
 var BRIDGE_METHODS = [
   "system.hello",
   "system.ping",
   "system.shutdown",
-  "opencode.server.ensure",
-  "opencode.server.status",
-  "opencode.session.create",
-  "opencode.session.prompt",
-  "opencode.session.status",
-  "opencode.session.abort",
-  "opencode.session.dispose"
+  "task.execute",
+  "task.cancel",
+  "task.list-running"
 ];
 function isBridgeMethod(value) {
   return typeof value === "string" && BRIDGE_METHODS.includes(value);
@@ -9481,7 +9480,7 @@ function isBridgeRequest(value) {
   if (!isRecord(value)) {
     return false;
   }
-  return value.protocolVersion === SERVICEME_PROTOCOL_VERSION && value.kind === "request" && typeof value.id === "string" && isBridgeMethod(value.method) && "params" in value;
+  return isValidProtocolVersion(value.protocolVersion) && value.kind === "request" && typeof value.id === "string" && isBridgeMethod(value.method) && "params" in value;
 }
 
 // ../../packages/serviceme-protocol/src/errors.ts
@@ -9497,8 +9496,22 @@ var SERVICEME_ERROR_CODES = [
   "opencode_request_failed",
   "opencode_backend_not_running",
   "opencode_session_not_found",
+  "copilot_not_installed",
+  "copilot_auth_required",
+  "copilot_execution_failed",
+  "copilot_timeout",
   "json_invalid_input",
   "env_tool_not_found",
+  "task_not_found",
+  "task_already_exists",
+  "invalid_schedule",
+  "invalid_payload",
+  "confirmation_required",
+  "workspace_not_found",
+  "daemon_not_running",
+  "executor_timeout",
+  "executor_error",
+  "task_already_running",
   "internal_error"
 ];
 var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
@@ -9507,6 +9520,8 @@ var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
   "opencode_startup_timeout",
   "opencode_request_failed",
   "opencode_backend_not_running",
+  "copilot_timeout",
+  "executor_timeout",
   "internal_error"
 ]);
 function isRecord2(value) {
@@ -9580,6 +9595,15 @@ function normalizeServicemeError(error, fallbackCode = "internal_error") {
     retryable: isRetryableErrorCode(fallbackCode)
   };
 }
+
+// src/version.ts
+var SERVICEME_CLI_VERSION = "0.1.2";
+
+// src/bridge/ndjson.ts
+function writeBridgeMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
 function terminateCommandProcess(child) {
   if (child.killed) {
     return;
@@ -9673,12 +9697,14 @@ async function runCommand(command, options2 = {}) {
     }
   });
 }
-async function commandExists(command) {
-  const isWindows = process.platform === "win32";
+
+// ../../packages/serviceme-core/src/copilot/doctor.ts
+var GH_COMMAND = "gh";
+async function isCopilotAuthenticated() {
   try {
-    await runCommand(isWindows ? "where" : "which", {
-      args: [command],
-      timeoutMs: 5e3
+    await runCommand(GH_COMMAND, {
+      args: ["auth", "status"],
+      timeoutMs: 1e4
     });
     return true;
   } catch {
@@ -9689,423 +9715,511 @@ async function commandExists(command) {
 // ../../packages/serviceme-core/src/json/jsonTools.ts
 __toESM(require_src2());
 
-// ../../packages/serviceme-core/src/logger.ts
-var noopLogger = {
-  debug() {
-  },
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  }
-};
-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(options2 = {}) {
-    this.stdoutBytes = 0;
-    this.options = {
-      ...DEFAULT_OPTIONS,
-      ...options2
-    };
-    this.logger = options2.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: {}
-      }
+// ../../packages/serviceme-core/src/utils/fileUtils.ts
+__toESM(require_yauzl());
+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
     );
-    this.resetIdleTimer();
-    return {
-      sessionId: session.id,
-      title: session.title,
-      status: "running"
-    };
+    const result = await handle.result;
+    return { ...result, output: output || result.output };
   }
-  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"
+  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;
     });
-    if (latestMessage) {
-      input.onEvent?.({
-        type: "message",
-        text: latestMessage
-      });
+    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);
     }
-    input.onEvent?.({
-      type: "completed"
+    if (p.agent) {
+      args.push("--agent", p.agent);
+    }
+    if (p.timeout != null) {
+      args.push("--timeout", String(p.timeout));
+    }
+    const child = child_process.spawn("serviceme", args, {
+      cwd: p.workspace,
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    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 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);
     });
-    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)
+    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);
     });
-    this.resetIdleTimer();
+    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 };
   }
-  async dispose() {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = void 0;
+};
+
+// ../../packages/serviceme-core/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();
+    const timer = setTimeout(() => {
+      ac.abort();
+    }, timeout);
+    if (abortSignal?.aborted) {
+      clearTimeout(timer);
+      return { status: "cancelled", error: "Execution aborted" };
     }
-    await this.terminateTrackedProcess("dispose");
-    this.startupPromise = void 0;
-  }
-  async ensureServerStarted(runtime) {
-    if (this.port) {
-      if (await this.isServerHealthy(this.port)) {
-        return;
+    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()
+        };
       }
-      await this.terminateTrackedProcess("restart-unhealthy");
-    }
-    if (this.startupPromise) {
-      await this.startupPromise;
-      return;
-    }
-    if (!await this.isAvailable()) {
-      throw createServicemeError(
-        "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;
+      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 };
     }
-    throw lastError;
   }
-  async startServerProcess(runtime) {
-    const port = crypto.randomInt(this.options.portMin, this.options.portMax + 1);
-    const child = child_process.spawn(this.options.command, ["--port", String(port)], {
-      cwd: runtime.workspaceRoot,
-      detached: process.platform !== "win32",
-      env: {
-        ...process.env,
-        OPENCODE_CALLER: "serviceme-cli"
+};
+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 = child_process.spawn("sh", ["-c", p.script], {
+      cwd: p.cwd,
       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;
-      }
+    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) => {
-      this.logger.warn("OpenCode stderr", chunk.toString());
+    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("error", (error) => {
-      this.logger.error("OpenCode process error", error);
-      if (this.childProcess === child) {
-        this.childProcess = void 0;
-        this.port = void 0;
+    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("exit", () => {
-      if (this.childProcess === child) {
-        this.childProcess = void 0;
-        this.port = void 0;
-      }
+    child.on("error", (err) => {
+      settle({ status: "failure", error: err.message });
     });
-    if (process.platform !== "win32" && child.pid) {
-      child_process.spawn("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 createServicemeError(
-        "opencode_startup_timeout",
-        "OpenCode local server did not start in time."
-      );
-    }
+    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 };
   }
-  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;
+};
+
+// ../../packages/serviceme-core/src/scheduled-tasks/executors/types.ts
+function isStreamingTaskExecutor(executor) {
+  return "executeStreaming" in executor && typeof executor.executeStreaming === "function";
+}
+
+// ../../packages/serviceme-core/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];
+}
+
+// ../../packages/serviceme-core/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;
   }
-  async isServerHealthy(port) {
-    try {
-      const response = await fetch(
-        `http://${this.options.host}:${port}${this.options.healthPath}`
-      );
-      return response.ok;
-    } catch {
-      return false;
-    }
+  setListener(listener) {
+    this.listener = listener;
   }
-  resetIdleTimer() {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
+  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`
+        );
+      }
     }
-    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;
+    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.logger.info("Stopping tracked OpenCode process", {
-      reason,
-      pid: child.pid
+    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
     });
-    if (process.platform === "win32") {
-      if (child.pid) {
-        await new Promise((resolve) => {
-          const killProcess = child_process.spawn(
-            "taskkill",
-            ["/pid", String(child.pid), "/T", "/F"],
-            {
-              stdio: "ignore",
-              windowsHide: true
-            }
-          );
-          killProcess.once("exit", () => resolve());
-          killProcess.once("error", () => {
-            child.kill();
-            resolve();
+    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
         });
-        return;
       }
-      child.kill();
-      return;
-    }
-    if (!child.pid) {
-      child.kill("SIGTERM");
-      return;
+    } 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);
+        }
+      }
     }
-    try {
-      process.kill(-child.pid, "SIGTERM");
-    } catch {
-      child.kill("SIGTERM");
-      return;
+  }
+  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();
     }
-    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();
-      });
+    this.running.clear();
+    this.taskExecutions.clear();
+  }
+};
+
+// src/bridge/TaskBridgeHandler.ts
+var TaskBridgeHandler = class {
+  constructor(logger, emitEvent) {
+    this.logger = logger;
+    this.emitEvent = emitEvent;
+    this.engine = new TaskExecutionEngine(
+      (taskType) => getExecutor(taskType)
+    );
+    this.engine.setListener({
+      onStarted: (params) => this.emitEvent("task.started", params),
+      onOutput: (params) => this.emitEvent("task.output", params),
+      onCompleted: (params) => this.emitEvent("task.completed", params),
+      onFailed: (params) => this.emitEvent("task.failed", params),
+      onCancelled: (params) => this.emitEvent("task.cancelled", params)
     });
   }
-  async request(path3, options2) {
-    if (!this.port) {
-      throw createServicemeError(
-        "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(options2.query ?? {})) {
-      if (value) {
-        url.searchParams.set(key, value);
-      }
-    }
-    const response = await fetch(url, {
-      method: options2.method,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: options2.body ? JSON.stringify(options2.body) : void 0,
-      signal: options2.signal
+  async execute(snapshot) {
+    let earlyError;
+    const executePromise = this.engine.execute(snapshot).catch((err) => {
+      earlyError = err;
     });
-    if (!response.ok) {
-      throw createServicemeError(
-        "opencode_request_failed",
-        `OpenCode request failed: ${response.status} ${response.statusText}`
-      );
+    await Promise.resolve();
+    if (earlyError) {
+      throw earlyError;
     }
-    if (response.status === 204) {
-      return void 0;
-    }
-    return await response.json();
+    executePromise.then(void 0, (err) => {
+      this.logger.error("Task execution background error", err);
+    });
+    return { executionId: snapshot.executionId, accepted: true };
   }
-  createQuery(workspaceRoot) {
-    return {
-      directory: workspaceRoot
-    };
+  cancel(params) {
+    const cancelled = this.engine.cancel(params.executionId);
+    return { executionId: params.executionId, cancelled };
   }
-  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");
+  listRunning() {
+    return { executions: this.engine.listRunning() };
   }
-  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";
-    }
+  dispose() {
+    this.engine.dispose();
   }
 };
 
-// ../../packages/serviceme-core/src/utils/fileUtils.ts
-__toESM(require_yauzl());
-
-// src/version.ts
-var SERVICEME_CLI_VERSION = "0.0.6";
-
-// src/bridge/ndjson.ts
-function writeBridgeMessage(message) {
-  process.stdout.write(`${JSON.stringify(message)}
-`);
-}
-
 // src/bridge/BridgeServer.ts
 var CAPABILITIES = {
   bridge: true,
-  opencode: 1,
   json: 1,
-  env: 1
+  env: 1,
+  tasks: 1
 };
 var BridgeServer = class {
-  constructor(logger, options2 = {}) {
+  constructor(logger) {
     this.logger = logger;
     this.handshakeCompleted = false;
-    this.shuttingDown = false;
-    this.openCodeManager = options2.openCodeManager ?? new OpenCodeManager({ logger });
+    this.taskHandler = new TaskBridgeHandler(logger, (event, params) => {
+      this.writeEvent(event, params);
+    });
   }
   async run() {
     const reader = readline__namespace.createInterface({
@@ -10117,7 +10231,7 @@ var BridgeServer = class {
         void this.handleLine(line);
       });
       reader.on("close", () => {
-        void this.dispose().finally(resolve);
+        resolve();
       });
     });
   }
@@ -10173,111 +10287,42 @@ var BridgeServer = class {
         }
         case "system.shutdown": {
           const shutdownRequest = request;
+          this.taskHandler.dispose();
           this.writeSuccess(shutdownRequest.id, {
             shuttingDown: true
           });
           queueMicrotask(() => {
-            void this.dispose().finally(() => {
-              process.exit(0);
-            });
+            process.exit(0);
           });
           return;
         }
-        case "opencode.server.ensure": {
-          const ensureRequest = request;
-          const result = await this.openCodeManager.ensureServer(
-            ensureRequest.params
-          );
-          this.writeSuccess(ensureRequest.id, result);
-          return;
-        }
-        case "opencode.server.status": {
-          const statusRequest = request;
-          const result = await this.openCodeManager.getServerState();
-          this.writeSuccess(statusRequest.id, result);
-          return;
-        }
-        case "opencode.session.create": {
-          const createRequest = request;
-          const result = await this.openCodeManager.createSession({
-            workspaceRoot: createRequest.params.workspaceRoot,
-            startupTimeoutMs: createRequest.params.runtime?.startupTimeoutMs
-          });
-          this.writeSuccess(createRequest.id, result);
-          return;
-        }
-        case "opencode.session.prompt": {
-          const promptRequest = request;
-          this.writeSuccess(promptRequest.id, {
-            accepted: true,
-            sessionId: promptRequest.params.sessionId,
-            promptId: promptRequest.params.promptId
-          });
-          void this.openCodeManager.prompt({
-            sessionId: promptRequest.params.sessionId,
-            prompt: promptRequest.params.prompt,
-            workspaceRoot: promptRequest.params.workspaceRoot,
-            onEvent: (payload) => {
-              this.writeEvent("opencode.session.event", {
-                sessionId: promptRequest.params.sessionId,
-                promptId: promptRequest.params.promptId,
-                payload
-              });
+        case "task.execute": {
+          const execRequest = request;
+          try {
+            const result = await this.taskHandler.execute(execRequest.params);
+            this.writeSuccess(request.id, result);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("TASK_ALREADY_RUNNING")) {
+              this.writeError(
+                request.id,
+                createServicemeError("task_already_running", message)
+              );
+            } else {
+              this.writeError(request.id, err);
             }
-          }).catch((error) => {
-            const normalized = normalizeServicemeError(error);
-            this.writeEvent("opencode.session.event", {
-              sessionId: promptRequest.params.sessionId,
-              promptId: promptRequest.params.promptId,
-              payload: {
-                type: "error",
-                text: normalized.message,
-                metadata: {
-                  code: normalized.code,
-                  retryable: normalized.retryable
-                }
-              }
-            });
-          });
+          }
           return;
         }
-        case "opencode.session.status": {
-          const statusRequest = request;
-          const status = await this.openCodeManager.getSessionStatus(
-            statusRequest.params.sessionId,
-            statusRequest.params.workspaceRoot
-          );
-          this.writeSuccess(statusRequest.id, {
-            sessionId: statusRequest.params.sessionId,
-            status
-          });
+        case "task.cancel": {
+          const cancelRequest = request;
+          const result = this.taskHandler.cancel(cancelRequest.params);
+          this.writeSuccess(request.id, result);
           return;
         }
-        case "opencode.session.abort": {
-          const abortRequest = request;
-          await this.openCodeManager.abortSession(
-            abortRequest.params.sessionId,
-            abortRequest.params.workspaceRoot
-          );
-          this.writeSuccess(abortRequest.id, {
-            aborted: true,
-            sessionId: abortRequest.params.sessionId
-          });
-          this.writeEvent("opencode.session.event", {
-            sessionId: abortRequest.params.sessionId,
-            payload: {
-              type: "status",
-              status: "aborted"
-            }
-          });
-          return;
-        }
-        case "opencode.session.dispose": {
-          const disposeRequest = request;
-          this.writeSuccess(disposeRequest.id, {
-            disposed: true,
-            sessionId: disposeRequest.params.sessionId
-          });
+        case "task.list-running": {
+          const result = this.taskHandler.listRunning();
+          this.writeSuccess(request.id, result);
           return;
         }
         default:
@@ -10319,13 +10364,6 @@ var BridgeServer = class {
       params
     });
   }
-  async dispose() {
-    if (this.shuttingDown) {
-      return;
-    }
-    this.shuttingDown = true;
-    await this.openCodeManager.dispose();
-  }
 };
 
 exports.BridgeServer = BridgeServer;