midsummer-sol 0.1.4 → 0.2.0

package/package.json

@@ -1,39 +1,15 @@
 {
   "name": "midsummer-sol",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Sol — agent-native version control (a new git). CLI, MCP server, and no-filesystem SDK.",
-  "bin": {
-    "sol": "./sol.js",
-    "sol-mcp": "./sol-mcp.js"
-  },
+  "bin": { "sol": "./sol.js", "sol-mcp": "./sol-mcp.js", "sol-secret-mcp": "./sol-secret-mcp.js" },
   "main": "./index.js",
-  "exports": {
-    ".": "./index.js"
-  },
+  "exports": { ".": "./index.js" },
   "type": "module",
-  "files": [
-    "sol.js",
-    "sol-mcp.js",
-    "index.js",
-    "README.md",
-    "LICENSE"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
+  "files": ["sol.js", "sol-mcp.js", "sol-secret-mcp.js", "index.js", "README.md", "LICENSE"],
+  "dependencies": { "@modelcontextprotocol/sdk": "^1.29.0" },
+  "engines": { "node": ">=18" },
   "license": "Apache-2.0",
-  "keywords": [
-    "vcs",
-    "git",
-    "version-control",
-    "agent",
-    "mcp",
-    "no-filesystem"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+  "keywords": ["vcs", "git", "version-control", "agent", "mcp", "no-filesystem"],
+  "publishConfig": { "access": "public" }
+}

package/sol-mcp.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 // @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/bin/sol-mcp.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { mkdirSync as mkdirSync2 } from "fs";
 import { join as join2 } from "path";
 
@@ -21,7 +20,9 @@ function canonicalOp(op) {
     path: op.path,
     rootAfter: op.rootAfter,
     by: op.by ?? null,
-    message: op.message ?? null
+    message: op.message ?? null,
+    ...op.kind !== undefined ? { kind: op.kind } : {},
+    ...op.prov !== undefined ? { prov: op.prov } : {}
   });
 }
 
@@ -53,7 +54,10 @@ function hashNode(node) {
     canon = node.encoding ? `blob\x00${node.encoding}\x00${node.content}` : `blob\x00${node.content}`;
   } else if (node.kind === "sealed")
     canon = `sealed\x00${node.box}`;
-  else
+  else if (node.kind === "prov") {
+    const f = (k, v) => v === undefined ? "" : `\x00${k}\x00${v}`;
+    canon = "prov" + f("agentId", node.agentId) + f("sessionId", node.sessionId) + f("model", node.model) + f("intent", node.intent) + f("tool", node.tool) + f("rationale", node.rationale) + f("parent", node.parent);
+  } else
     canon = "tree\x00" + Object.keys(node.entries).sort().map((k) => {
       const e = node.entries[k];
       return e.mode === undefined ? `${k}\x00${e.kind}\x00${e.hash}` : `${k}\x00${e.kind}\x00${e.hash}\x00${e.mode}`;
@@ -122,9 +126,128 @@ class MemoryAsyncStore {
   }
 }
 
+// src/struct.ts
+import { randomBytes } from "node:crypto";
+var SLOT_PREFIX = "\x00slot\x00";
+var HIDDEN_KEY = "\x00hidden";
+function isReservedKey(key) {
+  return key.startsWith("\x00");
+}
+function slotKey(slotId) {
+  return SLOT_PREFIX + slotId;
+}
+function slotIdFromKey(key) {
+  return key.startsWith(SLOT_PREFIX) ? key.slice(SLOT_PREFIX.length) : undefined;
+}
+function mintSlotId() {
+  return randomBytes(16).toString("base64url");
+}
+var STRUCT_HEADER = "__solStruct";
+function parseStruct(plaintext) {
+  if (!plaintext.startsWith("{"))
+    return;
+  let v;
+  try {
+    v = JSON.parse(plaintext);
+  } catch {
+    return;
+  }
+  if (!v || typeof v !== "object")
+    return;
+  const tag = v[STRUCT_HEADER];
+  if (tag === "subtree" || tag === "name" || tag === "entries")
+    return v;
+  return;
+}
+function nextBucket(n) {
+  let b = 256;
+  while (b < n)
+    b *= 2;
+  return b;
+}
+function padPlaintext(p) {
+  const bare = JSON.stringify(p);
+  const target = nextBucket(bare.length);
+  if (bare.length >= target)
+    return bare;
+  const overhead = `,"${"__pad"}":""`.length;
+  const fill = Math.max(0, target - bare.length - overhead);
+  return JSON.stringify({ ...p, __pad: " ".repeat(fill) });
+}
+async function collectAsync(store, hash, into) {
+  if (into[hash])
+    return;
+  const node = await store.get(hash);
+  if (!node)
+    throw new Error(`sealSubtree: node missing from store: ${hash}`);
+  into[hash] = node;
+  if (node.kind === "tree")
+    for (const e of Object.values(node.entries))
+      await collectAsync(store, e.hash, into);
+}
+async function serializeSubtreeAsync(store, dirRoot) {
+  const nodes = {};
+  await collectAsync(store, dirRoot, nodes);
+  return padPlaintext({ __solStruct: "subtree", bundle: { root: dirRoot, nodes } });
+}
+async function subtreeRootAt(store, root, dirPath) {
+  const segs = dirPath.split("/").filter(Boolean);
+  let cur = root;
+  for (let i = 0;i < segs.length; i++) {
+    const entry = (await getTree(store, cur)).entries[segs[i]];
+    if (!entry || entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return cur;
+}
+async function entryAt(store, root, path) {
+  const segs = path.split("/").filter(Boolean);
+  let cur = root;
+  for (let i = 0;i < segs.length; i++) {
+    const entry = (await getTree(store, cur)).entries[segs[i]];
+    if (!entry)
+      return;
+    if (i === segs.length - 1)
+      return entry;
+    if (entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return;
+}
+async function serializeNameAsync(store, name, entry) {
+  const nodes = {};
+  await collectAsync(store, entry.hash, nodes);
+  const payload = {
+    __solStruct: "name",
+    name,
+    entryKind: entry.kind,
+    ...entry.mode === undefined ? {} : { entryMode: entry.mode },
+    bundle: { root: entry.hash, nodes }
+  };
+  return padPlaintext(payload);
+}
+async function hiddenEntryAsync(store, entry) {
+  const nodes = {};
+  await collectAsync(store, entry.hash, nodes);
+  return { entryKind: entry.kind, ...entry.mode === undefined ? {} : { entryMode: entry.mode }, bundle: { root: entry.hash, nodes } };
+}
+function serializeHiddenEntries(slots) {
+  return padPlaintext({ __solStruct: "entries", slots });
+}
+
 // src/async-tree.ts
 function segments(path) {
-  return path.split("/").filter(Boolean);
+  const segs = path.split("/").filter(Boolean);
+  for (const s of segs) {
+    if (!s.includes("\x00"))
+      continue;
+    const reserved = s.startsWith("\x00slot\x00") ? s.slice("\x00slot\x00".length) : s === "\x00hidden" ? "" : undefined;
+    if (reserved === undefined || reserved.includes("\x00"))
+      throw new Error("illegal NUL byte in path");
+  }
+  return segs;
 }
 async function emptyRoot(store) {
   return store.put({ kind: "tree", entries: {} });
@@ -138,6 +261,70 @@ async function writeSealed(store, root, path, box) {
   const hash = await store.put({ kind: "sealed", box });
   return writeInto(store, root, segments(path), hash, "sealed");
 }
+async function hideName(store, root, path, box, slotId) {
+  const hash = await store.put({ kind: "sealed", box });
+  return hideInto(store, root, segments(path), hash, slotKey(slotId));
+}
+async function reHideName(store, root, dirSegs, key, box) {
+  const hash = await store.put({ kind: "sealed", box });
+  if (dirSegs.length === 0) {
+    const tree2 = await getTree(store, root);
+    return store.put({ kind: "tree", entries: { ...tree2.entries, [key]: { kind: "sealed", hash } } });
+  }
+  const tree = await getTree(store, root);
+  const entries = { ...tree.entries };
+  const [head, ...rest] = dirSegs;
+  const child = entries[head];
+  if (!child || child.kind !== "tree")
+    return root;
+  entries[head] = { kind: "tree", hash: await reHideName(store, child.hash, rest, key, box) };
+  return store.put({ kind: "tree", entries });
+}
+async function hideInto(store, treeHash, segs, sealedHash, key) {
+  const tree = await getTree(store, treeHash);
+  const entries = { ...tree.entries };
+  const [head, ...rest] = segs;
+  if (rest.length === 0) {
+    delete entries[head];
+    entries[key] = { kind: "sealed", hash: sealedHash };
+  } else {
+    const child = entries[head];
+    if (!child || child.kind !== "tree")
+      return treeHash;
+    entries[head] = { kind: "tree", hash: await hideInto(store, child.hash, rest, sealedHash, key) };
+  }
+  return store.put({ kind: "tree", entries });
+}
+async function hideExistence(store, root, path, hiddenBox) {
+  const hash = await store.put({ kind: "sealed", box: hiddenBox });
+  return hideExistenceInto(store, root, segments(path), hash);
+}
+async function hideExistenceInto(store, treeHash, segs, sidecarHash) {
+  const tree = await getTree(store, treeHash);
+  const entries = { ...tree.entries };
+  const [head, ...rest] = segs;
+  if (rest.length === 0) {
+    delete entries[head];
+    entries[HIDDEN_KEY] = { kind: "sealed", hash: sidecarHash };
+  } else {
+    const child = entries[head];
+    if (!child || child.kind !== "tree")
+      return treeHash;
+    entries[head] = { kind: "tree", hash: await hideExistenceInto(store, child.hash, rest, sidecarHash) };
+  }
+  return store.put({ kind: "tree", entries });
+}
+async function dirEntriesAt(store, root, dirPath) {
+  const segs = segments(dirPath);
+  let cur = root;
+  for (const seg of segs) {
+    const entry = (await getTree(store, cur)).entries[seg];
+    if (!entry || entry.kind !== "tree")
+      return;
+    cur = entry.hash;
+  }
+  return (await getTree(store, cur)).entries;
+}
 async function writeInto(store, treeHash, segs, hash, leafKind, mode) {
   const tree = await getTree(store, treeHash);
   const entries = { ...tree.entries };
@@ -265,6 +452,10 @@ async function listAll(store, root, prefix = "") {
   const tree = await getTree(store, root);
   const out = [];
   for (const [name, entry] of Object.entries(tree.entries)) {
+    if (isReservedKey(name)) {
+      out.push(prefix ? `${prefix}/${name}` : name);
+      continue;
+    }
     const p = prefix ? `${prefix}/${name}` : name;
     if (entry.kind === "tree")
       out.push(...await listAll(store, entry.hash, p));
@@ -274,6 +465,43 @@ async function listAll(store, root, prefix = "") {
   return out.sort();
 }
 
+// src/sign.ts
+var ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+
+// src/prov.ts
+function provenanceFromEnv(env = process.env) {
+  const kind = env.SOL_KIND === "agent" ? "agent" : "human";
+  const node = buildProvNode({
+    agentId: env.SOL_AGENT_ID || (kind === "agent" ? env.SOL_ACTOR : undefined),
+    sessionId: env.SOL_SESSION,
+    model: env.SOL_MODEL,
+    intent: env.SOL_INTENT,
+    tool: env.SOL_TOOL
+  });
+  return node ? { kind, node } : { kind };
+}
+function buildProvNode(fields) {
+  const clean = { kind: "prov" };
+  let any = false;
+  for (const k of ["agentId", "sessionId", "model", "intent", "tool", "rationale", "parent"]) {
+    const v = fields[k];
+    if (v) {
+      clean[k] = v;
+      any = true;
+    }
+  }
+  return any ? clean : undefined;
+}
+async function captureProv(sink, env = process.env) {
+  const { kind, node } = provenanceFromEnv(env);
+  const out = {};
+  if (kind === "agent")
+    out.kind = "agent";
+  if (node)
+    out.prov = await sink.put(node);
+  return out;
+}
+
 // src/types.ts
 var SEALED = "<<sealed>>";
 
@@ -284,14 +512,27 @@ function pageOps(ops, opts = {}) {
     out = out.slice(0, opts.limit);
   return out;
 }
+var noSign = (op) => op;
+
 class AsyncRepo {
   store;
   log;
   actor;
-  constructor(store, log, actor = "anon") {
+  sign;
+  constructor(store, log, actor = "anon", sign = noSign) {
     this.store = store;
     this.log = log;
     this.actor = actor;
+    this.sign = sign;
+  }
+  async appendAuthored(entry, by) {
+    await this.log.append(by === this.actor ? this.sign(entry) : entry);
+  }
+  provFor;
+  async provenance(by) {
+    if (by !== this.actor)
+      return {};
+    return this.provFor ??= captureProv(this.store);
   }
   async currentRoot() {
     const head = await this.log.head();
@@ -308,7 +549,7 @@ class AsyncRepo {
   }
   async writeFile(path, content, at = Date.now(), by = this.actor) {
     const rootAfter = await writeFile(this.store, await this.currentRoot(), path, content);
-    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by });
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by, ...await this.provenance(by) }, by);
     return rootAfter;
   }
   async applyBatch(changes) {
@@ -327,7 +568,7 @@ class AsyncRepo {
   }
   async writeBytes(path, data, at = Date.now(), by = this.actor) {
     const rootAfter = await writeFile(this.store, await this.currentRoot(), path, Buffer.from(data).toString("base64"), { encoding: "base64" });
-    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by });
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by, ...await this.provenance(by) }, by);
     return rootAfter;
   }
   async readBytes(path) {
@@ -346,7 +587,7 @@ class AsyncRepo {
     if (!f)
       return this.currentRoot();
     const rootAfter = await writeFile(this.store, await this.currentRoot(), path, f.content, { encoding: f.encoding, mode });
-    await this.log.append({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by: this.actor });
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "write", path, rootAfter, at, by: this.actor, ...await this.provenance(this.actor) }, this.actor);
     return rootAfter;
   }
   async mode(path) {
@@ -354,7 +595,96 @@ class AsyncRepo {
   }
   async writeSealed(path, box, at = Date.now()) {
     const rootAfter = await writeSealed(this.store, await this.currentRoot(), path, box);
-    await this.log.append({ seq: await this.log.seq() + 1, type: "seal", path, rootAfter, at, by: this.actor });
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "seal", path, rootAfter, at, by: this.actor, ...await this.provenance(this.actor) }, this.actor);
+    return rootAfter;
+  }
+  async sealSubtree(dirPath, seal, at = Date.now()) {
+    const subRoot = await subtreeRootAt(this.store, await this.currentRoot(), dirPath);
+    if (subRoot === undefined)
+      return;
+    const plaintext = await serializeSubtreeAsync(this.store, subRoot);
+    return this.writeSealed(dirPath, seal(plaintext), at);
+  }
+  async hideName(path, seal, opts = {}, at = Date.now()) {
+    const root = await this.currentRoot();
+    const segs = path.split("/").filter(Boolean);
+    const name = segs[segs.length - 1];
+    let entry = await entryAt(this.store, root, path);
+    if (!entry) {
+      if (opts.contentSeal && opts.absentContent !== undefined) {
+        const sealedHash = await this.store.put({ kind: "sealed", box: opts.contentSeal(opts.absentContent) });
+        entry = { kind: "sealed", hash: sealedHash };
+      } else {
+        return;
+      }
+    }
+    if (slotIdFromKey(name) !== undefined)
+      return slotIdFromKey(name);
+    if (opts.contentSeal && entry.kind === "blob") {
+      const blob = await this.store.get(entry.hash);
+      if (blob && blob.kind === "blob") {
+        const sealedHash = await this.store.put({ kind: "sealed", box: opts.contentSeal(blob.content) });
+        entry = entry.mode === undefined ? { kind: "sealed", hash: sealedHash } : { kind: "sealed", hash: sealedHash, mode: entry.mode };
+      }
+    }
+    const slotId = opts.slotId ?? mintSlotId();
+    const plaintext = await serializeNameAsync(this.store, name, entry);
+    const rootAfter = await hideName(this.store, root, path, seal(plaintext), slotId);
+    const slotPath = segs.length > 1 ? `${segs.slice(0, -1).join("/")}/${slotKey(slotId)}` : slotKey(slotId);
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "seal", path: slotPath, rootAfter, at, by: this.actor, ...await this.provenance(this.actor) }, this.actor);
+    return slotId;
+  }
+  async reHideName(realDir, name, slotId, newContent, seal, contentSeal, at = Date.now()) {
+    const root = await this.currentRoot();
+    const sealedHash = await this.store.put({ kind: "sealed", box: contentSeal(newContent) });
+    const childEntry = { kind: "sealed", hash: sealedHash };
+    const plaintext = await serializeNameAsync(this.store, name, childEntry);
+    const dirSegs = realDir.split("/").filter(Boolean);
+    const rootAfter = await reHideName(this.store, root, dirSegs, slotKey(slotId), seal(plaintext));
+    const slotPath = dirSegs.length ? `${dirSegs.join("/")}/${slotKey(slotId)}` : slotKey(slotId);
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "seal", path: slotPath, rootAfter, at, by: this.actor, ...await this.provenance(this.actor) }, this.actor);
+    return rootAfter;
+  }
+  async hideExistence(path, seal, opts = {}, at = Date.now()) {
+    const root = await this.currentRoot();
+    const segs = path.split("/").filter(Boolean);
+    const name = segs[segs.length - 1];
+    const dirPath = segs.slice(0, -1).join("/");
+    let entry = await entryAt(this.store, root, path);
+    if (name === HIDDEN_KEY)
+      return root;
+    if (!entry) {
+      if (opts.contentSeal && opts.absentContent !== undefined) {
+        const sealedHash = await this.store.put({ kind: "sealed", box: opts.contentSeal(opts.absentContent) });
+        entry = { kind: "sealed", hash: sealedHash };
+      } else {
+        return;
+      }
+    }
+    if (opts.contentSeal && entry.kind === "blob") {
+      const blob = await this.store.get(entry.hash);
+      if (blob && blob.kind === "blob") {
+        const sealedHash = await this.store.put({ kind: "sealed", box: opts.contentSeal(blob.content) });
+        entry = entry.mode === undefined ? { kind: "sealed", hash: sealedHash } : { kind: "sealed", hash: sealedHash, mode: entry.mode };
+      }
+    }
+    const slots = {};
+    const dirEntries = await dirEntriesAt(this.store, root, dirPath);
+    const prior = dirEntries?.[HIDDEN_KEY];
+    if (prior && prior.kind === "sealed" && opts.openPrior) {
+      const priorNode = await this.store.get(prior.hash);
+      if (priorNode && priorNode.kind === "sealed") {
+        const opened = opts.openPrior(priorNode.box);
+        const payload = opened === undefined ? undefined : parseStruct(opened);
+        if (payload?.__solStruct === "entries")
+          Object.assign(slots, payload.slots);
+      }
+    }
+    slots[name] = await hiddenEntryAsync(this.store, entry);
+    const plaintext = serializeHiddenEntries(slots);
+    const rootAfter = await hideExistence(this.store, root, path, seal(plaintext));
+    const hiddenPath = dirPath ? `${dirPath}/${HIDDEN_KEY}` : HIDDEN_KEY;
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "seal", path: hiddenPath, rootAfter, at, by: this.actor, ...await this.provenance(this.actor) }, this.actor);
     return rootAfter;
   }
   async read(path) {
@@ -362,7 +692,7 @@ class AsyncRepo {
   }
   async deleteFile(path, at = Date.now(), by = this.actor) {
     const rootAfter = await deleteFile(this.store, await this.currentRoot(), path);
-    await this.log.append({ seq: await this.log.seq() + 1, type: "delete", path, rootAfter, at, by });
+    await this.appendAuthored({ seq: await this.log.seq() + 1, type: "delete", path, rootAfter, at, by, ...await this.provenance(by) }, by);
     return rootAfter;
   }
   async readFile(path) {
@@ -393,8 +723,8 @@ function decodeObject(raw) {
 
 class FileStore {
   objects;
-  constructor(solDir) {
-    this.objects = join(solDir, "objects");
+  constructor(solDir, objectsDir) {
+    this.objects = objectsDir ?? join(solDir, "objects");
     mkdirSync(this.objects, { recursive: true });
   }
   path(hash) {
@@ -575,9 +905,6 @@ class SolWorkspace {
 }
 
 // src/bin/sol-mcp.ts
-var solDir = process.env.SOL_DIR || join2(process.cwd(), ".sol");
-mkdirSync2(solDir, { recursive: true });
-var ws = new SolWorkspace(new FileStore(solDir), new FileOpLog(solDir), process.env.SOL_ACTOR || "agent");
 var tools = [
   { name: "sol_write", description: "Create or overwrite a text file in the sol workspace. Authoring goes here \u2014 not to a disk.", inputSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
   { name: "sol_read", description: "Read a text file from the sol workspace.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
@@ -589,7 +916,7 @@ var tools = [
   { name: "sol_history", description: "Show the authoring history (the op-log).", inputSchema: { type: "object", properties: {} } }
 ];
 var text = (s) => ({ content: [{ type: "text", text: s }] });
-async function handle(name, a) {
+async function handle(ws, name, a) {
   switch (name) {
     case "sol_write":
       await ws.write(a.path, a.content);
@@ -626,13 +953,31 @@ async function handle(name, a) {
       throw new Error("unknown tool: " + name);
   }
 }
-var server = new Server({ name: "sol", version: "0.1.0" }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  try {
-    return await handle(req.params.name, req.params.arguments ?? {});
-  } catch (e) {
-    return { content: [{ type: "text", text: "sol error: " + (e?.message ?? e) }], isError: true };
-  }
-});
-await server.connect(new StdioServerTransport);
+async function startWorkspaceMcp(opts = {}) {
+  const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { CallToolRequestSchema, ListToolsRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
+  const solDir = opts.solDir || process.env.SOL_DIR || join2(process.cwd(), ".sol");
+  mkdirSync2(solDir, { recursive: true });
+  const ws = new SolWorkspace(new FileStore(solDir), new FileOpLog(solDir), process.env.SOL_ACTOR || "agent");
+  const server = new Server({ name: "sol", version: "0.1.0" }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    try {
+      return await handle(ws, req.params.name, req.params.arguments ?? {});
+    } catch (e) {
+      return { content: [{ type: "text", text: "sol error: " + (e?.message ?? e) }], isError: true };
+    }
+  });
+  await server.connect(new StdioServerTransport);
+}
+if (__require.main == __require.module) {
+  startWorkspaceMcp().catch((e) => {
+    process.stderr.write(`sol-mcp: ${e?.message ?? e}
+`);
+    process.exit(1);
+  });
+}
+export {
+  startWorkspaceMcp
+};