echospace 0.0.1 → 0.1.0-alpha.1

package/dist/cli/index.js

@@ -0,0 +1,916 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import getPort, { portNumbers } from "get-port";
+import fs3 from "fs";
+import { homedir } from "os";
+import path4 from "path";
+import open from "open";
+
+// src/server/services/config.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+var DEFAULT_CONFIG = {
+  providers: [
+    {
+      name: "openai",
+      type: "openai",
+      api_key: "",
+      models: ["gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano", "gpt-4o", "gpt-4o-mini", "o3", "o3-mini", "o4-mini"]
+    },
+    {
+      name: "anthropic",
+      type: "anthropic",
+      api_key: "",
+      models: ["claude-sonnet-4-6", "claude-haiku-4-5"]
+    },
+    {
+      name: "google",
+      type: "google",
+      api_key: "",
+      models: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"]
+    }
+  ]
+};
+function getConfigPath(configDir) {
+  return path.join(configDir, "config.yaml");
+}
+function loadConfig(configDir) {
+  const configPath = getConfigPath(configDir);
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return yaml.load(raw) ?? DEFAULT_CONFIG;
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function saveConfig(configDir, config) {
+  const configPath = getConfigPath(configDir);
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(configPath, yaml.dump(config), "utf-8");
+}
+function ensureConfig(configDir) {
+  const oldDir = configDir.replace(/\.echospace$/, ".echo-space");
+  if (oldDir !== configDir && fs.existsSync(oldDir) && !fs.existsSync(configDir)) {
+    fs.renameSync(oldDir, configDir);
+  }
+  const configPath = getConfigPath(configDir);
+  if (!fs.existsSync(configPath)) {
+    fs.mkdirSync(configDir, { recursive: true });
+    const header = [
+      "# EchoSpace configuration",
+      "# Fill in the api_key for the providers you need. Unconfigured providers are ignored.",
+      "# Run /echospace:init for interactive setup.",
+      ""
+    ].join("\n");
+    fs.writeFileSync(configPath, header + yaml.dump(DEFAULT_CONFIG), "utf-8");
+  }
+}
+
+// src/server/index.ts
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { Hono as Hono4 } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+
+// src/server/routes/chat.ts
+import { Hono } from "hono";
+import { stream } from "hono/streaming";
+
+// src/core/providers/anthropic.ts
+function toAnthropicContent(msg) {
+  const blocks = [];
+  for (const part of msg.parts) {
+    switch (part.type) {
+      case "text":
+        blocks.push({ type: "text", text: part.text });
+        break;
+      case "thinking":
+        blocks.push({ type: "thinking", thinking: part.text });
+        break;
+      case "tool_call":
+        blocks.push({
+          type: "tool_use",
+          id: part.id,
+          name: part.name,
+          input: part.input
+        });
+        break;
+      case "tool_result":
+        blocks.push({
+          type: "tool_result",
+          tool_use_id: part.id,
+          content: typeof part.output === "string" ? part.output : JSON.stringify(part.output),
+          is_error: part.is_error
+        });
+        break;
+      case "image":
+        if (part.base64) {
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: part.media_type ?? "image/png",
+              data: part.base64
+            }
+          });
+        }
+        break;
+    }
+  }
+  return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+var anthropicAdapter = {
+  type: "anthropic",
+  buildRequest(messages, settings, config) {
+    const baseUrl = config.base_url ?? "https://api.anthropic.com";
+    const url = `${baseUrl.replace(/\/$/, "")}/v1/messages`;
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const system = systemMessages.flatMap((m) => m.parts.filter((p) => p.type === "text")).map((p) => p.text).join("\n\n");
+    const body = {
+      model: settings.model ?? config.models[0],
+      messages: nonSystemMessages.map((msg) => ({
+        role: msg.role === "tool" ? "user" : msg.role,
+        content: toAnthropicContent(msg)
+      })),
+      max_tokens: settings.max_tokens ?? 4096,
+      stream: true
+    };
+    if (system) body.system = system;
+    if (settings.temperature != null) body.temperature = settings.temperature;
+    if (settings.top_p != null) body.top_p = settings.top_p;
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = settings.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }));
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    };
+    if (config.api_key) {
+      headers["x-api-key"] = config.api_key;
+    }
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    try {
+      const event = JSON.parse(chunk);
+      const parts = [];
+      switch (event.type) {
+        case "content_block_delta": {
+          const delta = event.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            parts.push({ type: "text", text: delta.text });
+          }
+          if (delta?.type === "thinking_delta" && delta.thinking) {
+            parts.push({ type: "thinking", text: delta.thinking });
+          }
+          if (delta?.type === "input_json_delta" && delta.partial_json) {
+            parts.push({
+              type: "tool_call",
+              id: "",
+              name: "",
+              input: delta.partial_json
+            });
+          }
+          break;
+        }
+        case "content_block_start": {
+          const block = event.content_block;
+          if (block?.type === "tool_use") {
+            parts.push({
+              type: "tool_call",
+              id: block.id ?? "",
+              name: block.name ?? "",
+              input: ""
+            });
+          }
+          break;
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    try {
+      const event = JSON.parse(chunk);
+      return event.type === "message_stop";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/providers/google.ts
+function toGeminiContent(msg) {
+  const parts = [];
+  for (const part of msg.parts) {
+    switch (part.type) {
+      case "text":
+      case "thinking":
+        parts.push({ text: part.text });
+        break;
+      case "tool_call":
+        parts.push({
+          functionCall: {
+            name: part.name,
+            args: typeof part.input === "string" ? JSON.parse(part.input) : part.input
+          }
+        });
+        break;
+      case "tool_result":
+        parts.push({
+          functionResponse: {
+            name: part.id,
+            response: { result: part.output }
+          }
+        });
+        break;
+      case "image":
+        if (part.base64) {
+          parts.push({
+            inlineData: {
+              mimeType: part.media_type ?? "image/png",
+              data: part.base64
+            }
+          });
+        }
+        break;
+    }
+  }
+  const role = msg.role === "assistant" ? "model" : "user";
+  return { role, parts };
+}
+var googleAdapter = {
+  type: "google",
+  buildRequest(messages, settings, config) {
+    const model = settings.model ?? config.models[0];
+    const baseUrl = config.base_url ?? "https://generativelanguage.googleapis.com/v1beta";
+    const url = `${baseUrl}/models/${model}:streamGenerateContent?alt=sse&key=${config.api_key ?? ""}`;
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const systemInstruction = systemMessages.length > 0 ? {
+      parts: systemMessages.flatMap(
+        (m) => m.parts.filter((p) => p.type === "text").map((p) => ({ text: p.text }))
+      )
+    } : void 0;
+    const body = {
+      contents: nonSystemMessages.map(toGeminiContent),
+      generationConfig: {
+        ...settings.temperature != null && {
+          temperature: settings.temperature
+        },
+        ...settings.max_tokens != null && {
+          maxOutputTokens: settings.max_tokens
+        },
+        ...settings.top_p != null && { topP: settings.top_p }
+      }
+    };
+    if (systemInstruction) body.systemInstruction = systemInstruction;
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = [
+        {
+          functionDeclarations: settings.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        }
+      ];
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    try {
+      const data = JSON.parse(chunk);
+      const candidate = data?.candidates?.[0];
+      if (!candidate?.content?.parts) return [];
+      const parts = [];
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          parts.push({ type: "text", text: part.text });
+        }
+        if (part.functionCall) {
+          parts.push({
+            type: "tool_call",
+            id: part.functionCall.name ?? "",
+            name: part.functionCall.name ?? "",
+            input: part.functionCall.args ?? {}
+          });
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    try {
+      const data = JSON.parse(chunk);
+      const candidate = data?.candidates?.[0];
+      return candidate?.finishReason === "STOP";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/providers/openai.ts
+function toOpenAIMessage(msg) {
+  const result = { role: msg.role };
+  const textParts = msg.parts.filter((p) => p.type === "text");
+  const toolCalls = msg.parts.filter((p) => p.type === "tool_call");
+  const toolResults = msg.parts.filter((p) => p.type === "tool_result");
+  const thinkingParts = msg.parts.filter((p) => p.type === "thinking");
+  if (msg.role === "tool" && toolResults.length > 0) {
+    const tr = toolResults[0];
+    result.content = typeof tr.output === "string" ? tr.output : JSON.stringify(tr.output);
+    result.tool_call_id = tr.id;
+    return result;
+  }
+  if (msg.role === "assistant") {
+    result.content = textParts.map((p) => p.text).join("") || null;
+    if (thinkingParts.length > 0) {
+      result.reasoning_content = thinkingParts.map((p) => p.text).join("");
+    }
+    if (toolCalls.length > 0) {
+      result.tool_calls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+        }
+      }));
+    }
+    return result;
+  }
+  result.content = textParts.map((p) => p.text).join("");
+  return result;
+}
+var openaiAdapter = {
+  type: "openai",
+  buildRequest(messages, settings, config) {
+    const baseUrl = config.base_url ?? "https://api.openai.com/v1";
+    const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const body = {
+      model: settings.model ?? config.models[0],
+      messages: messages.map(toOpenAIMessage),
+      stream: true
+    };
+    if (settings.temperature != null) body.temperature = settings.temperature;
+    if (settings.max_tokens != null) body.max_tokens = settings.max_tokens;
+    if (settings.top_p != null) body.top_p = settings.top_p;
+    if (settings.response_format && settings.response_format !== "text") {
+      if (settings.response_format === "json_schema" && settings.json_schema) {
+        body.response_format = {
+          type: "json_schema",
+          json_schema: settings.json_schema
+        };
+      } else {
+        body.response_format = { type: settings.response_format };
+      }
+    }
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = settings.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+          ...t.strict != null && { strict: t.strict }
+        }
+      }));
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.api_key) {
+      headers["Authorization"] = `Bearer ${config.api_key}`;
+    }
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    if (chunk === "[DONE]") return [];
+    try {
+      const data = JSON.parse(chunk);
+      const delta = data?.choices?.[0]?.delta;
+      if (!delta) return [];
+      const parts = [];
+      if (delta.content) {
+        parts.push({ type: "text", text: delta.content });
+      }
+      if (delta.reasoning_content) {
+        parts.push({ type: "thinking", text: delta.reasoning_content });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (tc.function) {
+            parts.push({
+              type: "tool_call",
+              id: tc.id ?? "",
+              name: tc.function.name ?? "",
+              input: tc.function.arguments ?? ""
+            });
+          }
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    return chunk === "[DONE]";
+  }
+};
+
+// src/core/providers/registry.ts
+var DefaultProviderRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  get(type) {
+    const adapter = this.adapters.get(type);
+    if (!adapter) {
+      throw new Error(`Unknown provider type: ${type}`);
+    }
+    return adapter;
+  }
+  register(adapter) {
+    this.adapters.set(adapter.type, adapter);
+  }
+};
+function createProviderRegistry() {
+  const registry = new DefaultProviderRegistry();
+  registry.register(openaiAdapter);
+  registry.register(anthropicAdapter);
+  registry.register(googleAdapter);
+  return registry;
+}
+
+// src/server/routes/chat.ts
+function chatRoutes(options) {
+  const app = new Hono();
+  const registry = createProviderRegistry();
+  app.post("/completions", async (c) => {
+    const body = await c.req.json();
+    const { messages, settings, provider: providerName } = body;
+    const config = loadConfig(options.configDir);
+    const providerList = config.providers ?? [];
+    const providerConfig = providerList.find(
+      (p) => p.name === providerName
+    );
+    if (!providerConfig) {
+      return c.json(
+        { error: `Provider "${providerName}" not found in config` },
+        400
+      );
+    }
+    const resolvedConfig = {
+      ...providerConfig,
+      api_key: resolveEnvVar(providerConfig.api_key)
+    };
+    const adapter = registry.get(resolvedConfig.type);
+    const { url, headers, body: requestBody } = adapter.buildRequest(
+      messages,
+      settings,
+      resolvedConfig
+    );
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        return c.json(
+          {
+            error: `Provider returned ${response.status}: ${errorText}`
+          },
+          response.status
+        );
+      }
+      return stream(c, async (s) => {
+        const reader = response.body?.getReader();
+        if (!reader) return;
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === ":") continue;
+            if (trimmed.startsWith("data: ")) {
+              const data = trimmed.slice(6);
+              const parts = adapter.parseChunk(data);
+              if (parts.length > 0) {
+                await s.write(
+                  `data: ${JSON.stringify({ parts })}
+
+`
+                );
+              }
+              if (adapter.isDone(data)) {
+                await s.write("data: [DONE]\n\n");
+                return;
+              }
+            }
+          }
+        }
+        await s.write("data: [DONE]\n\n");
+      });
+    } catch (err) {
+      return c.json(
+        { error: `Request failed: ${err.message}` },
+        500
+      );
+    }
+  });
+  return app;
+}
+function resolveEnvVar(value) {
+  if (!value) return value;
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "");
+}
+
+// src/server/routes/files.ts
+import { Hono as Hono2 } from "hono";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/core/echo/parser.ts
+import { nanoid } from "nanoid";
+function parseEcho(raw) {
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  if (lines.length === 0) {
+    throw new Error("Empty .echo file");
+  }
+  const records = lines.map((line, i) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid JSON on line ${i + 1}`);
+    }
+  });
+  const metaRecord = records[0];
+  if (!metaRecord || metaRecord.kind !== "meta") {
+    throw new Error("First line must be a meta record");
+  }
+  const messages = records.filter((r) => r.kind === "message").map(normalizeMessage);
+  return {
+    meta: metaRecord,
+    messages
+  };
+}
+function normalizeMessage(message) {
+  const raw = message;
+  let msg = message;
+  if (!msg.id) {
+    msg = { ...msg, id: nanoid(8) };
+  }
+  if (!msg.created_at && (raw.ts || raw.timestamp)) {
+    msg = { ...msg, created_at: raw.ts ?? raw.timestamp };
+  }
+  const needsPartNormalization = msg.parts.some((p) => {
+    if (p.type !== "tool_result") return false;
+    const r = p;
+    return !r.id && (r.tool_call_id || r.tool_use_id);
+  });
+  if (needsPartNormalization) {
+    msg = {
+      ...msg,
+      parts: msg.parts.map((p) => {
+        if (p.type !== "tool_result") return p;
+        const r = p;
+        if (!r.id && (r.tool_call_id || r.tool_use_id)) {
+          const { tool_call_id, tool_use_id, ...rest } = r;
+          return { ...rest, id: tool_call_id ?? tool_use_id };
+        }
+        return p;
+      })
+    };
+  }
+  return msg;
+}
+function serializeEcho(conversation) {
+  const records = [conversation.meta, ...conversation.messages];
+  return records.map((r) => JSON.stringify(r)).join("\n") + "\n";
+}
+
+// src/core/history/parser.ts
+function parseHistory(raw) {
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  const parsed = lines.map((line, i) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid JSON in history on line ${i + 1}`);
+    }
+  });
+  const eventMap = /* @__PURE__ */ new Map();
+  for (const e of parsed) {
+    eventMap.set(e.id, e);
+  }
+  const events = [...eventMap.values()];
+  return { events, eventMap };
+}
+function serializeHistory(history) {
+  return history.events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+}
+function serializeEvent(event) {
+  return JSON.stringify(event) + "\n";
+}
+
+// src/server/routes/files.ts
+function fileRoutes(options) {
+  const app = new Hono2();
+  app.get("/", async (c) => {
+    try {
+      const entries = await fs2.readdir(options.workspaceDir, {
+        withFileTypes: true,
+        recursive: false
+      });
+      const files = await Promise.all(
+        entries.filter((e) => e.isFile() && e.name.endsWith(".echo")).map(async (e) => {
+          const filePath = path2.join(options.workspaceDir, e.name);
+          const stat = await fs2.stat(filePath);
+          return {
+            name: e.name,
+            path: filePath,
+            modified_at: stat.mtime.toISOString(),
+            size: stat.size
+          };
+        })
+      );
+      files.sort(
+        (a, b) => new Date(b.modified_at).getTime() - new Date(a.modified_at).getTime()
+      );
+      return c.json({ files });
+    } catch (err) {
+      return c.json({ files: [] });
+    }
+  });
+  app.get("/:filename", async (c) => {
+    const filename = c.req.param("filename");
+    const filePath = path2.join(options.workspaceDir, filename);
+    try {
+      const raw = await fs2.readFile(filePath, "utf-8");
+      const conversation = parseEcho(raw);
+      return c.json({ conversation, raw });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to read ${filename}: ${err.message}` },
+        404
+      );
+    }
+  });
+  app.put("/:filename", async (c) => {
+    const filename = c.req.param("filename");
+    const filePath = path2.join(options.workspaceDir, filename);
+    const body = await c.req.json();
+    try {
+      const content = body.raw ?? serializeEcho(body.conversation);
+      await fs2.writeFile(filePath, content, "utf-8");
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to write ${filename}: ${err.message}` },
+        500
+      );
+    }
+  });
+  app.post("/", async (c) => {
+    const body = await c.req.json();
+    const filename = body.filename;
+    const filePath = path2.join(options.workspaceDir, filename);
+    try {
+      await fs2.access(filePath);
+      return c.json({ error: `${filename} already exists` }, 409);
+    } catch {
+    }
+    try {
+      const content = body.raw ?? serializeEcho(body.conversation);
+      await fs2.writeFile(filePath, content, "utf-8");
+      return c.json({ ok: true, path: filePath });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to create ${filename}: ${err.message}` },
+        500
+      );
+    }
+  });
+  app.delete("/:filename", async (c) => {
+    const filename = c.req.param("filename");
+    const filePath = path2.join(options.workspaceDir, filename);
+    try {
+      await fs2.unlink(filePath);
+      const historyPath = filePath + "-history";
+      try {
+        await fs2.unlink(historyPath);
+      } catch {
+      }
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to delete ${filename}: ${err.message}` },
+        500
+      );
+    }
+  });
+  app.get("/:filename/history", async (c) => {
+    const filename = c.req.param("filename");
+    const historyPath = path2.join(
+      options.workspaceDir,
+      filename + "-history"
+    );
+    try {
+      const raw = await fs2.readFile(historyPath, "utf-8");
+      const history = parseHistory(raw);
+      return c.json({ events: history.events });
+    } catch {
+      return c.json({ events: [] });
+    }
+  });
+  app.put("/:filename/history", async (c) => {
+    const filename = c.req.param("filename");
+    const historyPath = path2.join(
+      options.workspaceDir,
+      filename + "-history"
+    );
+    const { events } = await c.req.json();
+    try {
+      const history = { events, eventMap: new Map(events.map((e) => [e.id, e])) };
+      await fs2.writeFile(historyPath, serializeHistory(history), "utf-8");
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to compact history: ${err.message}` },
+        500
+      );
+    }
+  });
+  app.post("/:filename/history", async (c) => {
+    const filename = c.req.param("filename");
+    const historyPath = path2.join(
+      options.workspaceDir,
+      filename + "-history"
+    );
+    const event = await c.req.json();
+    try {
+      const line = serializeEvent(event);
+      await fs2.appendFile(historyPath, line, "utf-8");
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json(
+        { error: `Failed to append history: ${err.message}` },
+        500
+      );
+    }
+  });
+  return app;
+}
+
+// src/server/routes/config.ts
+import { Hono as Hono3 } from "hono";
+function configRoutes(options) {
+  const app = new Hono3();
+  app.get("/", async (c) => {
+    const config = loadConfig(options.configDir);
+    return c.json(config);
+  });
+  app.put("/", async (c) => {
+    const body = await c.req.json();
+    saveConfig(options.configDir, body);
+    return c.json({ ok: true });
+  });
+  app.get("/providers", async (c) => {
+    const config = loadConfig(options.configDir);
+    const providerList = config.providers ?? [];
+    const providers = providerList.filter((p) => {
+      if (p.api_key == null) return true;
+      const resolved = p.api_key.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "");
+      return resolved.length > 0;
+    }).map((p) => ({
+      name: p.name,
+      type: p.type,
+      models: p.models ?? []
+    }));
+    return c.json({ providers });
+  });
+  return app;
+}
+
+// src/server/index.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var clientDir = path3.resolve(__dirname, "../client");
+function createServer(options) {
+  const app = new Hono4();
+  app.use("*", logger());
+  app.use("*", cors());
+  app.route("/api/files", fileRoutes(options));
+  app.route("/api/chat", chatRoutes(options));
+  app.route("/api/config", configRoutes(options));
+  if (options.dev) {
+    const viteUrl = "http://localhost:5173";
+    app.all("*", async (c) => {
+      const url = new URL(c.req.url);
+      const target = `${viteUrl}${url.pathname}${url.search}`;
+      const res = await fetch(target, {
+        method: c.req.method,
+        headers: c.req.raw.headers,
+        body: c.req.method === "GET" || c.req.method === "HEAD" ? void 0 : c.req.raw.body,
+        // @ts-expect-error -- Node fetch supports duplex for streaming bodies
+        duplex: "half"
+      });
+      return new Response(res.body, {
+        status: res.status,
+        headers: res.headers
+      });
+    });
+  } else {
+    app.use("/*", serveStatic({ root: clientDir }));
+    app.get("*", serveStatic({ root: clientDir, path: "index.html" }));
+  }
+  return app;
+}
+function startServer(options) {
+  const app = createServer(options);
+  serve(
+    { fetch: app.fetch, port: options.port },
+    (info) => {
+      console.log(`EchoSpace running at http://localhost:${info.port}`);
+    }
+  );
+  return app;
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0-alpha.1";
+var CONFIG_DIR = path4.join(homedir(), ".echospace");
+function loadEnvFile(dir) {
+  const envPath = path4.join(dir, ".env");
+  if (!fs3.existsSync(envPath)) return;
+  const lines = fs3.readFileSync(envPath, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+var program = new Command();
+program.name("echospace").description("The best open-source local prompt debugging tool").version(VERSION).argument("[workdir]", "Workspace directory", ".").option("-p, --port <port>", "Port to serve on").option("--no-open", "Don't open browser automatically").action(async (workdir, options) => {
+  const baseDir = path4.resolve(process.cwd(), workdir);
+  const workspaceDir = path4.join(baseDir, ".echo");
+  loadEnvFile(baseDir);
+  loadEnvFile(process.cwd());
+  if (!fs3.existsSync(workspaceDir)) {
+    fs3.mkdirSync(workspaceDir, { recursive: true });
+  }
+  fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+  ensureConfig(CONFIG_DIR);
+  const port = options.port ? parseInt(options.port, 10) : await getPort({ port: portNumbers(7788, 7799) });
+  console.log(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551           EchoSpace v${VERSION.padEnd(12)}\u2551
+  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+  \u2551  Workspace: ${workspaceDir.padEnd(24)}\u2551
+  \u2551  URL:       http://localhost:${String(port).padEnd(8)}\u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  const isDev = process.env.NODE_ENV !== "production" && import.meta.url.includes("/src/");
+  startServer({ port, workspaceDir, configDir: CONFIG_DIR, dev: isDev });
+  if (options.open) {
+    await open(`http://localhost:${port}`);
+  }
+  const shutdown = () => {
+    console.log("\nShutting down EchoSpace...");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+});
+program.parse();