@serviceme/devtools-core 0.0.3

package/dist/index.mjs

@@ -0,0 +1,1217 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/env/environmentInspector.ts
+import {
+  KNOWN_ENVIRONMENT_TOOLS
+} from "@serviceme/devtools-protocol";
+import { createServicemeError } from "@serviceme/devtools-protocol";
+
+// src/process/runCommand.ts
+import { spawn } from "child_process";
+async function runCommand(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, options.args ?? [], {
+      cwd: options.cwd,
+      env: options.env,
+      shell: options.shell,
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    let finished = false;
+    let timeoutId;
+    const finish = (handler) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      handler();
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.once("close", (code) => {
+      finish(() => {
+        if (code === 0) {
+          resolve({
+            stdout,
+            stderr,
+            code: 0
+          });
+          return;
+        }
+        const error = new Error(
+          stderr || stdout || `Command failed with exit code ${String(code ?? 1)}.`
+        );
+        error.code = code ?? 1;
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+      });
+    });
+    if (options.stdin !== void 0) {
+      child.stdin?.end(options.stdin);
+    } else {
+      child.stdin?.end();
+    }
+    if (options.timeoutMs) {
+      timeoutId = setTimeout(() => {
+        finish(() => {
+          child.kill("SIGTERM");
+          const error = new Error(
+            `Command timed out after ${String(options.timeoutMs)}ms.`
+          );
+          error.code = "ETIMEDOUT";
+          error.stdout = stdout;
+          error.stderr = stderr;
+          reject(error);
+        });
+      }, options.timeoutMs);
+    }
+  });
+}
+async function commandExists(command) {
+  const isWindows = process.platform === "win32";
+  try {
+    await runCommand(isWindows ? "where" : "which", {
+      args: [command],
+      timeoutMs: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/env/environmentInspector.ts
+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)])
+    );
+    return Object.fromEntries(results);
+  }
+  async checkTool(toolName) {
+    if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
+      throw createServicemeError("invalid_params", "Invalid tool name.");
+    }
+    try {
+      if (toolName === "nvm") {
+        return await this.checkNvm();
+      }
+      if (toolName === "nuget") {
+        return await this.checkNuget();
+      }
+      const toolPath = await this.getToolPath(toolName);
+      const version = await this.getToolVersion(toolName);
+      return {
+        installed: true,
+        version,
+        path: toolPath
+      };
+    } catch (error) {
+      return this.handleToolCheckError(error);
+    }
+  }
+  async getToolPath(toolName) {
+    try {
+      const isWindows = process.platform === "win32";
+      const result = await runCommand(isWindows ? "where" : "which", {
+        args: [toolName],
+        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+      });
+      return result.stdout.trim().split("\n")[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
+    });
+    return this.parseVersion(toolName, result.stdout || result.stderr);
+  }
+  async checkNvm() {
+    if (process.platform === "win32") {
+      try {
+        const result = await runCommand("cmd.exe", {
+          args: ["/c", "nvm version"],
+          timeoutMs: TOOL_CHECK_TIMEOUT_MS
+        });
+        return {
+          installed: true,
+          version: result.stdout.trim(),
+          path: await this.getToolPath("nvm")
+        };
+      } catch {
+        return {
+          installed: false,
+          error: "Not installed"
+        };
+      }
+    }
+    try {
+      const result = await runCommand("/bin/bash", {
+        args: [
+          "-lc",
+          'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; nvm --version'
+        ],
+        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+      });
+      return {
+        installed: true,
+        version: result.stdout.trim(),
+        path: "$HOME/.nvm/nvm.sh"
+      };
+    } catch {
+      return {
+        installed: false,
+        error: "Not installed"
+      };
+    }
+  }
+  async checkNuget() {
+    const dotnetPath = await this.getToolPath("dotnet");
+    if (!dotnetPath) {
+      return {
+        installed: false,
+        error: "dotnet CLI is not installed"
+      };
+    }
+    try {
+      const result = await runCommand("dotnet", {
+        args: ["nuget", "list", "source"],
+        timeoutMs: TOOL_CHECK_TIMEOUT_MS
+      });
+      const privateSourceUrl = "http://192.168.20.209:10010/nuget";
+      if (result.stdout.includes(privateSourceUrl)) {
+        return {
+          installed: true,
+          version: "Configured",
+          path: privateSourceUrl
+        };
+      }
+      return {
+        installed: false,
+        error: "Private source not configured"
+      };
+    } catch (error) {
+      return this.handleToolCheckError(error);
+    }
+  }
+  getVersionCommand(toolName) {
+    const commands = {
+      git: "git --version",
+      node: "node --version",
+      npm: "npm --version",
+      pnpm: "pnpm --version",
+      nvm: "nvm --version",
+      nrm: "nrm --version",
+      dotnet: "dotnet --version"
+    };
+    return commands[toolName] || `${toolName} --version`;
+  }
+  parseVersion(toolName, output) {
+    const cleaned = output.trim();
+    switch (toolName) {
+      case "git": {
+        const match = cleaned.match(/git version (\d+\.\d+\.\d+)/);
+        return match?.[1] || cleaned;
+      }
+      case "node": {
+        const match = cleaned.match(/v?(\d+\.\d+\.\d+)/);
+        return match?.[1] || cleaned;
+      }
+      default: {
+        const semver = cleaned.match(/(\d+\.\d+\.\d+)/);
+        if (semver?.[1]) {
+          return semver[1];
+        }
+        const simple = cleaned.match(/(\d+\.\d+)/);
+        return simple?.[1] || cleaned;
+      }
+    }
+  }
+  handleToolCheckError(error) {
+    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;
+    return {
+      installed: false,
+      error: isNotFound ? "Not installed" : message
+    };
+  }
+};
+
+// src/image/imageTools.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import {
+  createServicemeError as createServicemeError2
+} from "@serviceme/devtools-protocol";
+var SUPPORTED_FORMATS = [".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff"];
+var DEFAULT_MINIMUM_COMPRESSION_RATIO = 5;
+var ImageTools = class {
+  getSupportedFormats() {
+    return [...SUPPORTED_FORMATS];
+  }
+  async validate(filePath, sharpModulePath) {
+    try {
+      if (!await this.pathExists(filePath)) {
+        return { valid: false };
+      }
+      if (!SUPPORTED_FORMATS.includes(path.extname(filePath).toLowerCase())) {
+        return { valid: false };
+      }
+      await this.getInfo(filePath, sharpModulePath);
+      return { valid: true };
+    } catch {
+      return { valid: false };
+    }
+  }
+  async getInfo(imagePath, sharpModulePath) {
+    const sharp = this.loadSharp(sharpModulePath);
+    const metadata = await sharp(imagePath).metadata();
+    const stats = await fs.stat(imagePath);
+    return {
+      width: metadata.width ?? 0,
+      height: metadata.height ?? 0,
+      format: metadata.format ?? "unknown",
+      size: stats.size,
+      colorSpace: metadata.space
+    };
+  }
+  async compress(imagePath, options) {
+    const validation = await this.validate(imagePath, options.sharpModulePath);
+    if (!validation.valid) {
+      throw createServicemeError2("invalid_params", `Invalid image file: ${imagePath}`);
+    }
+    const originalStats = await fs.stat(imagePath);
+    const originalSize = originalStats.size;
+    const outputPath = this.getOutputPath(imagePath, options);
+    const compressedBuffer = await this.compressWithSharp(imagePath, options);
+    const compressedSize = compressedBuffer.length;
+    const compressionRatio = (originalSize - compressedSize) / originalSize * 100;
+    const minimumCompressionRatio = options.minimumCompressionRatio ?? DEFAULT_MINIMUM_COMPRESSION_RATIO;
+    if (compressionRatio < minimumCompressionRatio) {
+      return {
+        originalSize,
+        compressedSize: originalSize,
+        compressionRatio: 0,
+        outputPath: imagePath
+      };
+    }
+    await fs.writeFile(outputPath, compressedBuffer);
+    return {
+      originalSize,
+      compressedSize,
+      compressionRatio,
+      outputPath
+    };
+  }
+  async compressWithSharp(imagePath, options) {
+    const sharp = this.loadSharp(options.sharpModulePath);
+    let pipeline = sharp(imagePath);
+    switch (options.format ?? path.extname(imagePath).toLowerCase().slice(1)) {
+      case "jpg":
+      case "jpeg":
+        pipeline = pipeline.jpeg({ quality: options.quality });
+        break;
+      case "png":
+        pipeline = pipeline.png({
+          quality: options.quality,
+          compressionLevel: 9
+        });
+        break;
+      case "webp":
+        pipeline = pipeline.webp({ quality: options.quality });
+        break;
+      default:
+        pipeline = pipeline.jpeg({ quality: options.quality });
+    }
+    return pipeline.toBuffer();
+  }
+  getOutputPath(inputPath, options) {
+    if (options.outputPath) {
+      return options.outputPath;
+    }
+    if (options.replaceOriginImage) {
+      return inputPath;
+    }
+    const dir = path.dirname(inputPath);
+    const ext = path.extname(inputPath);
+    const name = path.basename(inputPath, ext);
+    return path.join(dir, `${name}_compressed${ext}`);
+  }
+  async pathExists(targetPath) {
+    try {
+      await fs.access(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  loadSharp(sharpModulePath) {
+    try {
+      return sharpModulePath ? __require(sharpModulePath) : __require("sharp");
+    } catch (error) {
+      throw createServicemeError2(
+        "internal_error",
+        `sharp is required for image operations: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+function createImageTools() {
+  return new ImageTools();
+}
+
+// src/json/jsonTools.ts
+import { parse as parseCommentJson } from "comment-json";
+import JSON5 from "json5";
+import {
+  DEFAULT_JSON_SORT_OPTIONS
+} from "@serviceme/devtools-protocol";
+import { createServicemeError as createServicemeError3 } from "@serviceme/devtools-protocol";
+function createJsonTools() {
+  return {
+    sort(text, options) {
+      const finalOptions = { ...DEFAULT_JSON_SORT_OPTIONS, ...options };
+      const json = parseJson(text);
+      const sorted = sortObject(json, finalOptions);
+      return JSON.stringify(sorted, null, detectIndent(text));
+    },
+    format(text, indent = 2) {
+      return JSON.stringify(parseJson(text), null, indent);
+    },
+    validate(text) {
+      try {
+        parseJson(text);
+        return { valid: true };
+      } catch (error) {
+        return {
+          valid: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    minify(text) {
+      return JSON.stringify(parseJson(text));
+    }
+  };
+}
+function parseJson(text) {
+  const parsers = [
+    () => JSON.parse(text),
+    () => parseCommentJson(text),
+    () => JSON5.parse(text)
+  ];
+  for (const parser of parsers) {
+    try {
+      return parser();
+    } catch {
+    }
+  }
+  throw createServicemeError3("json_invalid_input", "Invalid JSON format.");
+}
+function sortObject(obj, options) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sortObject(item, options));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const record = obj;
+    const sortedKeys = sortKeys(Object.keys(record), options);
+    const result = {};
+    for (const key of sortedKeys) {
+      result[key] = sortObject(record[key], options);
+    }
+    return result;
+  }
+  return obj;
+}
+function sortKeys(keys, options) {
+  let compareFn;
+  switch (options.sortAlgo) {
+    case "keyLength":
+      compareFn = (a, b) => a.length - b.length;
+      break;
+    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;
+  }
+  const sorted = [...keys].sort(compareFn);
+  return options.sortOrder === "desc" ? sorted.reverse() : sorted;
+}
+function detectIndent(text) {
+  for (const line of text.split("\n")) {
+    const match = line.match(/^(\s+)/);
+    if (match?.[1]) {
+      return match[1].length;
+    }
+  }
+  return 2;
+}
+
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") {
+      return arg;
+    }
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function createConsoleLogger(prefix = "serviceme") {
+  return {
+    debug(message, ...args) {
+      process.stderr.write(`[${prefix}] DEBUG ${message} ${formatArgs(args)}
+`);
+    },
+    info(message, ...args) {
+      process.stderr.write(`[${prefix}] INFO ${message} ${formatArgs(args)}
+`);
+    },
+    warn(message, ...args) {
+      process.stderr.write(`[${prefix}] WARN ${message} ${formatArgs(args)}
+`);
+    },
+    error(message, ...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
+} from "@serviceme/devtools-protocol";
+
+// src/utils/fileUtils.ts
+import { constants, createWriteStream } from "fs";
+import {
+  access as access2,
+  copyFile,
+  lstat,
+  mkdir,
+  readdir,
+  rename,
+  rm
+} from "fs/promises";
+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);
+      });
+    });
+  });
+};
+var tryLstat = async (targetPath) => {
+  try {
+    return await lstat(targetPath);
+  } catch {
+    return null;
+  }
+};
+var mergeEntry = async (sourcePath, destPath, overwrite) => {
+  const sourceStat = await lstat(sourcePath);
+  const destStat = await tryLstat(destPath);
+  if (sourceStat.isDirectory()) {
+    if (destStat && !destStat.isDirectory()) {
+      if (!overwrite) {
+        await rm(sourcePath, { recursive: true, force: true });
+        return;
+      }
+      await rm(destPath, { recursive: true, force: true });
+    }
+    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 rm(sourcePath, { recursive: true, force: true });
+    return;
+  }
+  if (destStat) {
+    if (!overwrite) {
+      await rm(sourcePath, { recursive: true, force: true });
+      return;
+    }
+    await rm(destPath, { recursive: true, force: true });
+  }
+  try {
+    await rename(sourcePath, destPath);
+  } catch {
+    await copyFile(sourcePath, destPath);
+    await rm(sourcePath, { recursive: true, force: true });
+  }
+};
+var moveFiles = async (sourceDir, destDir, overwrite = false) => {
+  await mkdir(destDir, { recursive: true });
+  const files = await readdir(sourceDir);
+  for (const file of files) {
+    const sourceFile = join2(sourceDir, file);
+    const destFile = join2(destDir, file);
+    if (!overwrite) {
+      try {
+        await access2(destFile, constants.F_OK);
+        await rm(sourceFile, { recursive: true, force: true });
+        continue;
+      } catch {
+      }
+    }
+    await mergeEntry(sourceFile, destFile, overwrite);
+  }
+};
+
+// src/project/projectTools.ts
+var ProjectTools = class {
+  async extractTemplate(zipPath, workspacePath, tempExtractDir, input) {
+    await unzipFile(zipPath, tempExtractDir);
+    let sourceDir = path2.join(tempExtractDir, input.extractedDirName);
+    let actualDirName = input.extractedDirName;
+    if (!await this.pathExists(sourceDir)) {
+      const entries = await fs2.readdir(tempExtractDir, { withFileTypes: true });
+      const directories = entries.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".")
+      );
+      const selectedDirectory = await this.selectExtractedDirectory(
+        directories.map((directory) => directory.name),
+        tempExtractDir,
+        input.projectFilePattern,
+        input.extractedDirName
+      );
+      if (selectedDirectory) {
+        actualDirName = selectedDirectory;
+        sourceDir = path2.join(tempExtractDir, actualDirName);
+      } else if (directories.length === 0) {
+        throw new Error(
+          `No directory found after extraction. Expected directory: ${input.extractedDirName}`
+        );
+      } else {
+        throw new Error(
+          `Multiple directories found after extraction: ${directories.map((directory) => directory.name).join(", ")}. Expected: ${input.extractedDirName}`
+        );
+      }
+    }
+    if (!await this.pathExists(sourceDir)) {
+      throw new Error(`Source directory not found: ${sourceDir}`);
+    }
+    await moveFiles(sourceDir, workspacePath, true);
+    return {
+      actualDirName
+    };
+  }
+  async installDependencies(workspacePath, command) {
+    if (!command) {
+      throw createServicemeError5("invalid_params", "Expected install command.");
+    }
+    await runCommand(command, {
+      cwd: workspacePath,
+      shell: true
+    });
+    return {
+      installed: true,
+      command
+    };
+  }
+  async makeScriptsExecutable(workspacePath) {
+    const isWindows = process.platform === "win32";
+    const scripts = await this.findScripts(
+      workspacePath,
+      isWindows ? [".ps1", ".bat"] : [".sh"]
+    );
+    let updatedCount = 0;
+    if (isWindows) {
+      for (const scriptPath of scripts.filter((script) => script.endsWith(".ps1"))) {
+        try {
+          await runCommand(`powershell -Command "Unblock-File -Path '${scriptPath}'"`, {
+            cwd: workspacePath,
+            shell: true
+          });
+          updatedCount += 1;
+        } catch {
+        }
+      }
+    } else {
+      for (const scriptPath of scripts) {
+        try {
+          await fs2.chmod(scriptPath, 493);
+          updatedCount += 1;
+        } catch {
+        }
+      }
+    }
+    return {
+      processedCount: scripts.length,
+      updatedCount,
+      platform: process.platform,
+      scripts
+    };
+  }
+  async initializeGit(workspacePath) {
+    const command = "git init";
+    await runCommand(command, {
+      cwd: workspacePath,
+      shell: true
+    });
+    return {
+      initialized: true,
+      command
+    };
+  }
+  async runScaffoldPrune(workspacePath, preset) {
+    if (!preset) {
+      throw createServicemeError5("invalid_params", "Expected scaffold preset.");
+    }
+    const commands = [
+      `pnpm run scaffold:prune -- --preset ${preset} --project-root .`,
+      `pnpm run scaffold:init-metadata -- --preset ${preset} --project-root . --force`
+    ];
+    for (const command of commands) {
+      await runCommand(command, {
+        cwd: workspacePath,
+        shell: true
+      });
+    }
+    return {
+      applied: true,
+      preset,
+      commands
+    };
+  }
+  async findScripts(dir, extensions) {
+    const results = [];
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+        results.push(...await this.findScripts(fullPath, extensions));
+      } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+  async pathExists(targetPath) {
+    try {
+      await fs2.access(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async selectExtractedDirectory(directoryNames, tempExtractDir, projectFilePattern, expectedDirName) {
+    if (directoryNames.length === 1) {
+      return directoryNames[0] ?? null;
+    }
+    const exactMatch = directoryNames.find((directoryName) => directoryName === expectedDirName);
+    if (exactMatch) {
+      return exactMatch;
+    }
+    const matches = [];
+    for (const directoryName of directoryNames) {
+      if (await this.directoryMatchesProjectPattern(
+        path2.join(tempExtractDir, directoryName),
+        projectFilePattern
+      )) {
+        matches.push(directoryName);
+      }
+    }
+    if (matches.length === 1) {
+      return matches[0] ?? null;
+    }
+    return null;
+  }
+  async directoryMatchesProjectPattern(directoryPath, projectFilePattern) {
+    const entries = await fs2.readdir(directoryPath);
+    if (projectFilePattern.includes("*")) {
+      const regex = new RegExp(`^${projectFilePattern.replace("*", ".*")}$`);
+      return entries.some((entry) => regex.test(entry));
+    }
+    return entries.includes(projectFilePattern);
+  }
+};
+function createProjectTools() {
+  return new ProjectTools();
+}
+export {
+  EnvironmentInspector,
+  ImageTools,
+  OpenCodeManager,
+  ProjectTools,
+  createConsoleLogger,
+  createImageTools,
+  createJsonTools,
+  createProjectTools,
+  moveFiles,
+  noopLogger,
+  unzipFile
+};