@plannotator/opencode 0.17.10 → 0.18.0

package/dist/index.js

@@ -40429,11 +40429,12 @@ class OpenCodeProvider {
   server = null;
   client = null;
   startPromise = null;
+  lastAttachError = null;
   constructor(config) {
     this.config = config;
   }
   async ensureServer() {
-    if (this.server && this.client)
+    if (this.client)
       return;
     this.startPromise ??= this.doStart().catch((err) => {
       this.startPromise = null;
@@ -40442,27 +40443,71 @@ class OpenCodeProvider {
     return this.startPromise;
   }
   async doStart() {
+    this.lastAttachError = null;
     const { createOpencodeServer: createOpencodeServer2, createOpencodeClient: createOpencodeClient2 } = await getSDK();
-    this.server = await createOpencodeServer2({
-      hostname: this.config.hostname ?? "127.0.0.1",
-      ...this.config.port != null && { port: this.config.port },
-      timeout: 15000
-    });
+    const attachedClient = await this.tryAttachExistingServer(createOpencodeClient2);
+    if (attachedClient) {
+      this.client = attachedClient;
+      return;
+    }
+    try {
+      this.server = await createOpencodeServer2({
+        hostname: this.config.hostname ?? "127.0.0.1",
+        ...this.config.port != null && { port: this.config.port },
+        timeout: 15000
+      });
+    } catch (err) {
+      const spawnMessage = err instanceof Error ? err.message : String(err);
+      if (this.lastAttachError) {
+        throw new Error(`${this.lastAttachError}
+Fallback startup also failed: ${spawnMessage}`);
+      }
+      throw err;
+    }
     this.client = createOpencodeClient2({
       baseUrl: this.server.url,
       directory: this.config.cwd ?? process.cwd()
     });
   }
+  async tryAttachExistingServer(createOpencodeClient2) {
+    const cwd = this.config.cwd ?? process.cwd();
+    const baseUrl = `http://${this.config.hostname ?? "127.0.0.1"}:${this.config.port ?? 4096}`;
+    const client3 = createOpencodeClient2({
+      baseUrl,
+      directory: cwd
+    });
+    try {
+      await client3.config.get({
+        throwOnError: true,
+        signal: AbortSignal.timeout(1000)
+      });
+      return client3;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.lastAttachError = `Failed to attach to existing OpenCode server at ${baseUrl}: ${message}`;
+      return null;
+    }
+  }
+  getClient() {
+    if (!this.client) {
+      throw new Error("OpenCode client is not initialized.");
+    }
+    return this.client;
+  }
   async createSession(options) {
     await this.ensureServer();
-    const result = await this.client.session.create({
+    const client3 = this.getClient();
+    const result = await client3.session.create({
       query: { directory: options.cwd ?? this.config.cwd ?? process.cwd() }
     });
     const sessionData = result.data;
+    if (!sessionData) {
+      throw new Error("OpenCode did not return session data.");
+    }
     const session = new OpenCodeSession({
       sessionId: sessionData.id,
       systemPrompt: buildSystemPrompt(options.context),
-      client: this.client,
+      client: client3,
       model: options.model,
       parentSessionId: null
     });
@@ -40470,29 +40515,34 @@ class OpenCodeProvider {
   }
   async forkSession(options) {
     await this.ensureServer();
+    const client3 = this.getClient();
     const parentId = options.context.parent?.sessionId;
     if (!parentId) {
       throw new Error("Fork requires a parent session ID.");
     }
-    const result = await this.client.session.fork({
+    const result = await client3.session.fork({
       path: { id: parentId }
     });
     const sessionData = result.data;
+    if (!sessionData) {
+      throw new Error("OpenCode did not return forked session data.");
+    }
     return new OpenCodeSession({
       sessionId: sessionData.id,
       systemPrompt: buildSystemPrompt(options.context),
-      client: this.client,
+      client: client3,
       model: options.model,
       parentSessionId: parentId
     });
   }
   async resumeSession(sessionId) {
     await this.ensureServer();
-    await this.client.session.get({ path: { id: sessionId } });
+    const client3 = this.getClient();
+    await client3.session.get({ path: { id: sessionId } });
     return new OpenCodeSession({
       sessionId,
       systemPrompt: null,
-      client: this.client,
+      client: client3,
       model: undefined,
       parentSessionId: null
     });
@@ -40501,26 +40551,30 @@ class OpenCodeProvider {
     if (this.server) {
       this.server.close();
       this.server = null;
-      this.client = null;
-      this.startPromise = null;
     }
+    this.client = null;
+    this.startPromise = null;
   }
   async fetchModels() {
     try {
       await this.ensureServer();
-      const result = await this.client.provider.list({
+      const client3 = this.getClient();
+      const result = await client3.provider.list({
         query: { directory: this.config.cwd ?? process.cwd() }
       });
       const data = result.data;
-      const connected = new Set(data.connected);
-      const allProviders = data.all;
+      if (!data) {
+        return;
+      }
+      const connected = new Set(data.connected ?? []);
+      const allProviders = data.all ?? [];
       const models = [];
       for (const provider of allProviders) {
         if (!connected.has(provider.id))
           continue;
         for (const model of Object.values(provider.models)) {
           models.push({
-            id: `${model.providerID}/${model.id}`,
+            id: `${provider.id}/${model.id}`,
             label: model.name ?? model.id
           });
         }
@@ -40828,8 +40882,8 @@ async function openEditorDiff(oldPath, newPath) {
 
 // ../../packages/server/integrations.ts
 var {$: $2 } = globalThis.Bun;
-import { join as join2 } from "path";
-import { mkdirSync, existsSync as existsSync2, statSync } from "fs";
+import { join as join3 } from "path";
+import { mkdirSync, existsSync as existsSync3, statSync } from "fs";
 
 // ../../packages/server/project.ts
 var {$ } = globalThis.Bun;
@@ -41007,6 +41061,202 @@ Last Edited: ${now}
 ---`;
 }
 
+// ../../packages/shared/resolve-file.ts
+import { homedir } from "os";
+import { isAbsolute, join as join2, resolve, win32 } from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+var MARKDOWN_PATH_REGEX = /\.mdx?$/i;
+var WINDOWS_DRIVE_PATH_PATTERNS = [
+  /^\/cygdrive\/([a-zA-Z])\/(.+)$/,
+  /^\/([a-zA-Z])\/(.+)$/
+];
+var IGNORED_DIRS = [
+  "node_modules/",
+  ".git/",
+  "dist/",
+  "build/",
+  ".next/",
+  "__pycache__/",
+  ".obsidian/",
+  ".trash/"
+];
+function normalizeSeparators(input) {
+  return input.replace(/\\/g, "/");
+}
+function stripTrailingSlashes(input) {
+  return input.replace(/\/+$/, "");
+}
+function expandHomePath(input, home = homedir()) {
+  if (input === "~") {
+    return home;
+  }
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return join2(home, input.slice(2));
+  }
+  return input;
+}
+function stripWrappingQuotes(input) {
+  if (input.length < 2) {
+    return input;
+  }
+  const first = input[0];
+  const last = input[input.length - 1];
+  if (first === '"' && last === '"' || first === "'" && last === "'") {
+    return input.slice(1, -1);
+  }
+  return input;
+}
+function normalizeUserPathInput(input, platform = process.platform) {
+  const trimmedInput = input.trim();
+  const unquotedInput = stripWrappingQuotes(trimmedInput);
+  const expandedInput = expandHomePath(unquotedInput);
+  if (platform !== "win32") {
+    return expandedInput;
+  }
+  for (const pattern of WINDOWS_DRIVE_PATH_PATTERNS) {
+    const match = expandedInput.match(pattern);
+    if (!match) {
+      continue;
+    }
+    const [, driveLetter, rest] = match;
+    return `${driveLetter.toUpperCase()}:/${rest}`;
+  }
+  return expandedInput;
+}
+function isAbsoluteNormalizedUserPath(input, platform = process.platform) {
+  if (hasWindowsDriveLetter(input)) {
+    return true;
+  }
+  return platform === "win32" ? win32.isAbsolute(input) : isAbsolute(input);
+}
+function isAbsoluteUserPath(input, platform = process.platform) {
+  return isAbsoluteNormalizedUserPath(normalizeUserPathInput(input, platform), platform);
+}
+function resolveUserPath(input, baseDir = process.cwd(), platform = process.platform) {
+  const normalizedInput = normalizeUserPathInput(input, platform);
+  if (!normalizedInput) {
+    return "";
+  }
+  return isAbsoluteNormalizedUserPath(normalizedInput, platform) ? resolveAbsolutePath(normalizedInput, platform) : resolve(baseDir, normalizedInput);
+}
+function normalizeComparablePath(input) {
+  return stripTrailingSlashes(normalizeSeparators(resolveUserPath(input)));
+}
+function isWithinProjectRoot(candidate, projectRoot) {
+  const normalizedCandidate = normalizeComparablePath(candidate);
+  const normalizedProjectRoot = normalizeComparablePath(projectRoot);
+  return normalizedCandidate === normalizedProjectRoot || normalizedCandidate.startsWith(`${normalizedProjectRoot}/`);
+}
+function getLowercaseBasename(input) {
+  const normalizedInput = normalizeSeparators(input);
+  return normalizedInput.split("/").pop().toLowerCase();
+}
+function getLookupKey(input, isBareFilename) {
+  return isBareFilename ? getLowercaseBasename(input) : input.toLowerCase();
+}
+function resolveAbsolutePath(input, platform = process.platform) {
+  return platform === "win32" || hasWindowsDriveLetter(input) ? win32.resolve(input) : resolve(input);
+}
+function isSearchableMarkdownPath(input) {
+  return MARKDOWN_PATH_REGEX.test(input.trim());
+}
+function hasWindowsDriveLetter(input) {
+  return /^[a-zA-Z]:[/\\]/.test(input);
+}
+function fileExists(filePath) {
+  try {
+    return existsSync2(filePath);
+  } catch {
+    return false;
+  }
+}
+function walkMarkdownFiles(dir, root, results, ignoredDirs) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (ignoredDirs.some((d) => d === entry.name + "/"))
+        continue;
+      walkMarkdownFiles(join2(dir, entry.name), root, results, ignoredDirs);
+    } else if (entry.isFile() && /\.mdx?$/i.test(entry.name)) {
+      const relative = join2(dir, entry.name).slice(root.length + 1).replace(/\\/g, "/");
+      results.push(relative);
+    }
+  }
+}
+function resolveMarkdownFileCore(input, projectRoot) {
+  const normalizedInput = normalizeUserPathInput(input);
+  const searchInput = normalizeSeparators(normalizedInput);
+  const isBareFilename = !searchInput.includes("/");
+  const targetLookupKey = getLookupKey(searchInput, isBareFilename);
+  if (!isSearchableMarkdownPath(normalizedInput)) {
+    return { kind: "not_found", input };
+  }
+  if (isAbsoluteNormalizedUserPath(normalizedInput)) {
+    const absolutePath = resolveAbsolutePath(normalizedInput);
+    if (fileExists(absolutePath)) {
+      return { kind: "found", path: absolutePath };
+    }
+    return { kind: "not_found", input };
+  }
+  const fromRoot = resolve(projectRoot, searchInput);
+  if (isWithinProjectRoot(fromRoot, projectRoot) && fileExists(fromRoot)) {
+    return { kind: "found", path: fromRoot };
+  }
+  const allFiles = [];
+  walkMarkdownFiles(projectRoot, projectRoot, allFiles, IGNORED_DIRS);
+  const matches = [];
+  for (const match of allFiles) {
+    const normalizedMatch = normalizeSeparators(match);
+    const matchLookupKey = getLookupKey(normalizedMatch, isBareFilename);
+    if (matchLookupKey === targetLookupKey) {
+      const full = resolve(projectRoot, normalizedMatch);
+      if (isWithinProjectRoot(full, projectRoot)) {
+        matches.push(full);
+      }
+    }
+  }
+  if (matches.length === 1) {
+    return { kind: "found", path: matches[0] };
+  }
+  if (matches.length > 1) {
+    const projectRootPrefix = `${normalizeComparablePath(projectRoot)}/`;
+    const relative = matches.map((match) => normalizeComparablePath(match).replace(projectRootPrefix, ""));
+    return { kind: "ambiguous", input, matches: relative };
+  }
+  return { kind: "not_found", input };
+}
+function resolveMarkdownFile(input, projectRoot) {
+  const originalInput = input.trim();
+  const unquotedInput = stripWrappingQuotes(originalInput);
+  const primary = resolveMarkdownFileCore(unquotedInput, projectRoot);
+  if (primary.kind === "found") {
+    return primary;
+  }
+  if (primary.kind === "ambiguous") {
+    return { ...primary, input: originalInput };
+  }
+  if (!unquotedInput.startsWith("@")) {
+    return { kind: "not_found", input: originalInput };
+  }
+  const normalizedInput = unquotedInput.replace(/^@+/, "");
+  if (!normalizedInput) {
+    return { kind: "not_found", input: originalInput };
+  }
+  const fallback = resolveMarkdownFileCore(normalizedInput, projectRoot);
+  if (fallback.kind === "found") {
+    return fallback;
+  }
+  if (fallback.kind === "ambiguous") {
+    return { ...fallback, input: originalInput };
+  }
+  return { kind: "not_found", input: originalInput };
+}
+
 // ../../packages/server/integrations.ts
 async function extractTags(markdown) {
   const tags = new Set(["plannotator"]);
@@ -41049,12 +41299,11 @@ async function extractTags(markdown) {
 async function saveToObsidian(config) {
   try {
     const { vaultPath, folder, plan } = config;
-    let normalizedVault = vaultPath.trim();
-    if (normalizedVault.startsWith("~")) {
-      const home = process.env.HOME || process.env.USERPROFILE || "";
-      normalizedVault = join2(home, normalizedVault.slice(1));
+    if (!vaultPath?.trim()) {
+      return { success: false, error: "Vault path is required" };
     }
-    if (!existsSync2(normalizedVault)) {
+    const normalizedVault = resolveUserPath(vaultPath);
+    if (!existsSync3(normalizedVault)) {
       return {
         success: false,
         error: `Vault path does not exist: ${normalizedVault}`
@@ -41068,12 +41317,12 @@ async function saveToObsidian(config) {
       };
     }
     const folderName = folder.trim() || "plannotator";
-    const targetFolder = join2(normalizedVault, folderName);
-    if (!existsSync2(targetFolder)) {
+    const targetFolder = join3(normalizedVault, folderName);
+    if (!existsSync3(targetFolder)) {
       mkdirSync(targetFolder, { recursive: true });
     }
     const filename = generateFilename(plan, config.filenameFormat, config.filenameSeparator);
-    const filePath = join2(targetFolder, filename);
+    const filePath = join3(targetFolder, filename);
     const tags = await extractTags(plan);
     const frontmatter = generateFrontmatter(tags);
     const content = `${frontmatter}
@@ -41129,17 +41378,16 @@ ${plan}`;
 }
 
 // ../../packages/shared/storage.ts
-import { homedir } from "os";
-import { join as join3, resolve, sep } from "path";
-import { mkdirSync as mkdirSync2, writeFileSync, readFileSync as readFileSync2, readdirSync, statSync as statSync2, existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4, resolve as resolve2, sep } from "path";
+import { mkdirSync as mkdirSync2, writeFileSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync4 } from "fs";
 function getPlanDir(customPath) {
   let planDir;
-  if (customPath) {
-    planDir = customPath.startsWith("~") ? join3(homedir(), customPath.slice(1)) : customPath;
+  if (customPath?.trim()) {
+    planDir = resolveUserPath(customPath);
   } else {
-    planDir = join3(homedir(), ".plannotator", "plans");
+    planDir = join4(homedir2(), ".plannotator", "plans");
   }
-  planDir = resolve(planDir);
   mkdirSync2(planDir, { recursive: true });
   return planDir;
 }
@@ -41157,13 +41405,13 @@ function generateSlug(plan) {
 }
 function saveAnnotations(slug, annotationsContent, customPath) {
   const planDir = getPlanDir(customPath);
-  const filePath = join3(planDir, `${slug}.annotations.md`);
+  const filePath = join4(planDir, `${slug}.annotations.md`);
   writeFileSync(filePath, annotationsContent, "utf-8");
   return filePath;
 }
 function saveFinalSnapshot(slug, status, plan, annotations, customPath) {
   const planDir = getPlanDir(customPath);
-  const filePath = join3(planDir, `${slug}-${status}.md`);
+  const filePath = join4(planDir, `${slug}-${status}.md`);
   let content = plan;
   if (annotations && annotations !== "No changes detected.") {
     content += `
@@ -41198,7 +41446,7 @@ function parseArchiveFilename(filename) {
 function listArchivedPlans(customPath) {
   const planDir = getPlanDir(customPath);
   try {
-    const entries = readdirSync(planDir);
+    const entries = readdirSync2(planDir);
     const plans = [];
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
@@ -41207,7 +41455,7 @@ function listArchivedPlans(customPath) {
       if (!parsed)
         continue;
       try {
-        const stat = statSync2(join3(planDir, entry));
+        const stat = statSync2(join4(planDir, entry));
         parsed.size = stat.size;
         parsed.timestamp = stat.mtime.toISOString();
       } catch {}
@@ -41220,7 +41468,7 @@ function listArchivedPlans(customPath) {
 }
 function readArchivedPlan(filename, customPath) {
   const planDir = getPlanDir(customPath);
-  const filePath = resolve(planDir, filename);
+  const filePath = resolve2(planDir, filename);
   if (!filePath.startsWith(planDir + sep))
     return null;
   try {
@@ -41230,13 +41478,13 @@ function readArchivedPlan(filename, customPath) {
   }
 }
 function getHistoryDir(project, slug) {
-  const historyDir = join3(homedir(), ".plannotator", "history", project, slug);
+  const historyDir = join4(homedir2(), ".plannotator", "history", project, slug);
   mkdirSync2(historyDir, { recursive: true });
   return historyDir;
 }
 function getNextVersionNumber(historyDir) {
   try {
-    const entries = readdirSync(historyDir);
+    const entries = readdirSync2(historyDir);
     let max = 0;
     for (const entry of entries) {
       const match = entry.match(/^(\d+)\.md$/);
@@ -41255,7 +41503,7 @@ function saveToHistory(project, slug, plan) {
   const historyDir = getHistoryDir(project, slug);
   const nextVersion = getNextVersionNumber(historyDir);
   if (nextVersion > 1) {
-    const latestPath = join3(historyDir, `${String(nextVersion - 1).padStart(3, "0")}.md`);
+    const latestPath = join4(historyDir, `${String(nextVersion - 1).padStart(3, "0")}.md`);
     try {
       const existing = readFileSync2(latestPath, "utf-8");
       if (existing === plan) {
@@ -41264,14 +41512,14 @@ function saveToHistory(project, slug, plan) {
     } catch {}
   }
   const fileName = `${String(nextVersion).padStart(3, "0")}.md`;
-  const filePath = join3(historyDir, fileName);
+  const filePath = join4(historyDir, fileName);
   writeFileSync(filePath, plan, "utf-8");
   return { version: nextVersion, path: filePath, isNew: true };
 }
 function getPlanVersion(project, slug, version) {
-  const historyDir = join3(homedir(), ".plannotator", "history", project, slug);
+  const historyDir = join4(homedir2(), ".plannotator", "history", project, slug);
   const fileName = `${String(version).padStart(3, "0")}.md`;
-  const filePath = join3(historyDir, fileName);
+  const filePath = join4(historyDir, fileName);
   try {
     return readFileSync2(filePath, "utf-8");
   } catch {
@@ -41279,30 +41527,30 @@ function getPlanVersion(project, slug, version) {
   }
 }
 function getPlanVersionPath(project, slug, version) {
-  const historyDir = join3(homedir(), ".plannotator", "history", project, slug);
+  const historyDir = join4(homedir2(), ".plannotator", "history", project, slug);
   const fileName = `${String(version).padStart(3, "0")}.md`;
-  const filePath = join3(historyDir, fileName);
-  return existsSync3(filePath) ? filePath : null;
+  const filePath = join4(historyDir, fileName);
+  return existsSync4(filePath) ? filePath : null;
 }
 function getVersionCount(project, slug) {
-  const historyDir = join3(homedir(), ".plannotator", "history", project, slug);
+  const historyDir = join4(homedir2(), ".plannotator", "history", project, slug);
   try {
-    const entries = readdirSync(historyDir);
+    const entries = readdirSync2(historyDir);
     return entries.filter((e) => /^\d+\.md$/.test(e)).length;
   } catch {
     return 0;
   }
 }
 function listVersions(project, slug) {
-  const historyDir = join3(homedir(), ".plannotator", "history", project, slug);
+  const historyDir = join4(homedir2(), ".plannotator", "history", project, slug);
   try {
-    const entries = readdirSync(historyDir);
+    const entries = readdirSync2(historyDir);
     const versions = [];
     for (const entry of entries) {
       const match = entry.match(/^(\d+)\.md$/);
       if (match) {
         const version = parseInt(match[1], 10);
-        const filePath = join3(historyDir, entry);
+        const filePath = join4(historyDir, entry);
         try {
           const stat = statSync2(filePath);
           versions.push({ version, timestamp: stat.mtime.toISOString() });
@@ -41387,15 +41635,15 @@ async function getRepoInfo() {
 }
 
 // ../../packages/shared/config.ts
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
 import { execSync } from "child_process";
-var CONFIG_DIR = join4(homedir2(), ".plannotator");
-var CONFIG_PATH = join4(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join5(homedir3(), ".plannotator");
+var CONFIG_PATH = join5(CONFIG_DIR, "config.json");
 function loadConfig() {
   try {
-    if (!existsSync4(CONFIG_PATH))
+    if (!existsSync5(CONFIG_PATH))
       return {};
     const raw = readFileSync3(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
@@ -41542,7 +41790,7 @@ async function openBrowser(url, options) {
 }
 
 // ../../packages/server/image.ts
-import { resolve as resolve2, join as join5 } from "path";
+import { resolve as resolve3, join as join6 } from "path";
 import { tmpdir } from "os";
 var ALLOWED_IMAGE_EXTENSIONS = new Set([
   "png",
@@ -41557,7 +41805,7 @@ var ALLOWED_IMAGE_EXTENSIONS = new Set([
   "tif",
   "avif"
 ]);
-var UPLOAD_DIR = join5(tmpdir(), "plannotator");
+var UPLOAD_DIR = join6(tmpdir(), "plannotator");
 function getExtension(filePath) {
   const lastDot = filePath.lastIndexOf(".");
   if (lastDot === -1)
@@ -41568,7 +41816,7 @@ function hasImageExtension(filePath) {
   return ALLOWED_IMAGE_EXTENSIONS.has(getExtension(filePath));
 }
 function validateImagePath(rawPath) {
-  const resolved = resolve2(rawPath);
+  const resolved = resolve3(rawPath);
   if (!hasImageExtension(resolved)) {
     return {
       valid: false,
@@ -41591,12 +41839,12 @@ function validateUploadExtension(fileName) {
 }
 
 // ../../packages/shared/draft.ts
-import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, unlinkSync, existsSync as existsSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, unlinkSync, existsSync as existsSync6 } from "fs";
 import { createHash } from "crypto";
 function getDraftDir() {
-  const dir = join6(homedir3(), ".plannotator", "drafts");
+  const dir = join7(homedir4(), ".plannotator", "drafts");
   mkdirSync4(dir, { recursive: true });
   return dir;
 }
@@ -41605,12 +41853,12 @@ function contentHash(content) {
 }
 function saveDraft(key, data) {
   const dir = getDraftDir();
-  writeFileSync3(join6(dir, `${key}.json`), JSON.stringify(data), "utf-8");
+  writeFileSync3(join7(dir, `${key}.json`), JSON.stringify(data), "utf-8");
 }
 function loadDraft(key) {
-  const filePath = join6(getDraftDir(), `${key}.json`);
+  const filePath = join7(getDraftDir(), `${key}.json`);
   try {
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return null;
     return JSON.parse(readFileSync4(filePath, "utf-8"));
   } catch {
@@ -41618,9 +41866,9 @@ function loadDraft(key) {
   }
 }
 function deleteDraft(key) {
-  const filePath = join6(getDraftDir(), `${key}.json`);
+  const filePath = join7(getDraftDir(), `${key}.json`);
   try {
-    if (existsSync5(filePath))
+    if (existsSync6(filePath))
       unlinkSync(filePath);
   } catch {}
 }
@@ -41801,180 +42049,6 @@ function buildFileTree(relativePaths) {
   return root;
 }
 
-// ../../packages/shared/resolve-file.ts
-import { isAbsolute, join as join7, resolve as resolve3, win32 } from "path";
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
-var MARKDOWN_PATH_REGEX = /\.mdx?$/i;
-var WINDOWS_DRIVE_PATH_PATTERNS = [
-  /^\/cygdrive\/([a-zA-Z])\/(.+)$/,
-  /^\/([a-zA-Z])\/(.+)$/
-];
-var IGNORED_DIRS = [
-  "node_modules/",
-  ".git/",
-  "dist/",
-  "build/",
-  ".next/",
-  "__pycache__/",
-  ".obsidian/",
-  ".trash/"
-];
-function normalizeSeparators(input) {
-  return input.replace(/\\/g, "/");
-}
-function stripTrailingSlashes(input) {
-  return input.replace(/\/+$/, "");
-}
-function normalizeComparablePath(input) {
-  return stripTrailingSlashes(normalizeSeparators(resolve3(input)));
-}
-function isWithinProjectRoot(candidate, projectRoot) {
-  const normalizedCandidate = normalizeComparablePath(candidate);
-  const normalizedProjectRoot = normalizeComparablePath(projectRoot);
-  return normalizedCandidate === normalizedProjectRoot || normalizedCandidate.startsWith(`${normalizedProjectRoot}/`);
-}
-function getLowercaseBasename(input) {
-  const normalizedInput = normalizeSeparators(input);
-  return normalizedInput.split("/").pop().toLowerCase();
-}
-function getLookupKey(input, isBareFilename) {
-  return isBareFilename ? getLowercaseBasename(input) : input.toLowerCase();
-}
-function resolveAbsolutePath(input, platform = process.platform) {
-  return platform === "win32" || hasWindowsDriveLetter(input) ? win32.resolve(input) : resolve3(input);
-}
-function isSearchableMarkdownPath(input) {
-  return MARKDOWN_PATH_REGEX.test(input.trim());
-}
-function stripWrappingQuotes(input) {
-  if (input.length < 2) {
-    return input;
-  }
-  const first = input[0];
-  const last = input[input.length - 1];
-  if (first === '"' && last === '"' || first === "'" && last === "'") {
-    return input.slice(1, -1);
-  }
-  return input;
-}
-function hasWindowsDriveLetter(input) {
-  return /^[a-zA-Z]:[/\\]/.test(input);
-}
-function fileExists(filePath) {
-  try {
-    return existsSync6(filePath);
-  } catch {
-    return false;
-  }
-}
-function walkMarkdownFiles(dir, root, results, ignoredDirs) {
-  let entries;
-  try {
-    entries = readdirSync2(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (ignoredDirs.some((d) => d === entry.name + "/"))
-        continue;
-      walkMarkdownFiles(join7(dir, entry.name), root, results, ignoredDirs);
-    } else if (entry.isFile() && /\.mdx?$/i.test(entry.name)) {
-      const relative = join7(dir, entry.name).slice(root.length + 1).replace(/\\/g, "/");
-      results.push(relative);
-    }
-  }
-}
-function normalizeMarkdownPathInput(input, platform = process.platform) {
-  if (platform !== "win32") {
-    return input;
-  }
-  for (const pattern of WINDOWS_DRIVE_PATH_PATTERNS) {
-    const match = input.match(pattern);
-    if (!match) {
-      continue;
-    }
-    const [, driveLetter, rest] = match;
-    return `${driveLetter.toUpperCase()}:/${rest}`;
-  }
-  return input;
-}
-function isAbsoluteMarkdownPath(input, platform = process.platform) {
-  const normalizedInput = normalizeMarkdownPathInput(input, platform);
-  if (hasWindowsDriveLetter(normalizedInput)) {
-    return true;
-  }
-  return platform === "win32" ? win32.isAbsolute(normalizedInput) : isAbsolute(normalizedInput);
-}
-function resolveMarkdownFileCore(input, projectRoot) {
-  const normalizedInput = normalizeMarkdownPathInput(input);
-  const searchInput = normalizeSeparators(normalizedInput);
-  const isBareFilename = !searchInput.includes("/");
-  const targetLookupKey = getLookupKey(searchInput, isBareFilename);
-  if (!isSearchableMarkdownPath(normalizedInput)) {
-    return { kind: "not_found", input };
-  }
-  if (isAbsoluteMarkdownPath(normalizedInput)) {
-    const absolutePath = resolveAbsolutePath(normalizedInput);
-    if (fileExists(absolutePath)) {
-      return { kind: "found", path: absolutePath };
-    }
-    return { kind: "not_found", input };
-  }
-  const fromRoot = resolve3(projectRoot, searchInput);
-  if (isWithinProjectRoot(fromRoot, projectRoot) && fileExists(fromRoot)) {
-    return { kind: "found", path: fromRoot };
-  }
-  const allFiles = [];
-  walkMarkdownFiles(projectRoot, projectRoot, allFiles, IGNORED_DIRS);
-  const matches = [];
-  for (const match of allFiles) {
-    const normalizedMatch = normalizeSeparators(match);
-    const matchLookupKey = getLookupKey(normalizedMatch, isBareFilename);
-    if (matchLookupKey === targetLookupKey) {
-      const full = resolve3(projectRoot, normalizedMatch);
-      if (isWithinProjectRoot(full, projectRoot)) {
-        matches.push(full);
-      }
-    }
-  }
-  if (matches.length === 1) {
-    return { kind: "found", path: matches[0] };
-  }
-  if (matches.length > 1) {
-    const projectRootPrefix = `${normalizeComparablePath(projectRoot)}/`;
-    const relative = matches.map((match) => normalizeComparablePath(match).replace(projectRootPrefix, ""));
-    return { kind: "ambiguous", input, matches: relative };
-  }
-  return { kind: "not_found", input };
-}
-function resolveMarkdownFile(input, projectRoot) {
-  const originalInput = input.trim();
-  const unquotedInput = stripWrappingQuotes(originalInput);
-  const primary = resolveMarkdownFileCore(unquotedInput, projectRoot);
-  if (primary.kind === "found") {
-    return primary;
-  }
-  if (primary.kind === "ambiguous") {
-    return { ...primary, input: originalInput };
-  }
-  if (!unquotedInput.startsWith("@")) {
-    return { kind: "not_found", input: originalInput };
-  }
-  const normalizedInput = unquotedInput.replace(/^@+/, "");
-  if (!normalizedInput) {
-    return { kind: "not_found", input: originalInput };
-  }
-  const fallback = resolveMarkdownFileCore(normalizedInput, projectRoot);
-  if (fallback.kind === "found") {
-    return fallback;
-  }
-  if (fallback.kind === "ambiguous") {
-    return { ...fallback, input: originalInput };
-  }
-  return { kind: "not_found", input: originalInput };
-}
-
 // ../../node_modules/.bun/turndown@7.2.4/node_modules/turndown/lib/turndown.es.js
 function extend(destination) {
   for (var i = 1;i < arguments.length; i++) {
@@ -42664,8 +42738,9 @@ async function handleDoc(req) {
     return Response.json({ error: "Missing path parameter" }, { status: 400 });
   }
   const base = url.searchParams.get("base");
-  if (base && !requestedPath.startsWith("/") && /\.(mdx?|html?)$/i.test(requestedPath)) {
-    const fromBase = resolve4(base, requestedPath);
+  const resolvedBase = base ? resolveUserPath(base) : null;
+  if (resolvedBase && !isAbsoluteUserPath(requestedPath) && /\.(mdx?|html?)$/i.test(requestedPath)) {
+    const fromBase = resolveUserPath(requestedPath, resolvedBase);
     try {
       const file = Bun.file(fromBase);
       if (await file.exists()) {
@@ -42677,7 +42752,7 @@ async function handleDoc(req) {
   }
   const projectRoot = process.cwd();
   if (/\.html?$/i.test(requestedPath)) {
-    const resolvedHtml = resolve4(base || projectRoot, requestedPath);
+    const resolvedHtml = resolveUserPath(requestedPath, resolvedBase || projectRoot);
     if (!isWithinProjectRoot(resolvedHtml, projectRoot)) {
       return Response.json({ error: "Access denied: path is outside project root" }, { status: 403 });
     }
@@ -42718,7 +42793,7 @@ async function handleObsidianFiles(req) {
   if (!vaultPath) {
     return Response.json({ error: "Missing vaultPath parameter" }, { status: 400 });
   }
-  const resolvedVault = resolve4(vaultPath);
+  const resolvedVault = resolveUserPath(vaultPath);
   if (!existsSync7(resolvedVault) || !statSync3(resolvedVault).isDirectory()) {
     return Response.json({ error: "Invalid vault path" }, { status: 400 });
   }
@@ -42750,7 +42825,7 @@ async function handleObsidianDoc(req) {
   if (!/\.mdx?$/i.test(filePath)) {
     return Response.json({ error: "Only markdown files are supported" }, { status: 400 });
   }
-  const resolvedVault = resolve4(vaultPath);
+  const resolvedVault = resolveUserPath(vaultPath);
   let resolvedFile = resolve4(resolvedVault, filePath);
   if (!existsSync7(resolvedFile) && !filePath.includes("/")) {
     const glob = new Bun.Glob(`**/${filePath}`);
@@ -42793,7 +42868,7 @@ async function handleFileBrowserFiles(req) {
   if (!dirPath) {
     return Response.json({ error: "Missing dirPath parameter" }, { status: 400 });
   }
-  const resolvedDir = resolve4(dirPath);
+  const resolvedDir = resolveUserPath(dirPath);
   if (!existsSync7(resolvedDir) || !statSync3(resolvedDir).isDirectory()) {
     return Response.json({ error: "Invalid directory path" }, { status: 400 });
   }
@@ -44937,16 +45012,16 @@ function createAgentJobHandler(options) {
 
 // ../../packages/server/codex-review.ts
 import { join as join9 } from "path";
-import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
 import { appendFile, mkdir, unlink, writeFile, readFile } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 var DEBUG_ENABLED = !!process.env.PLANNOTATOR_DEBUG;
-var DEBUG_LOG_PATH = join9(homedir4(), ".plannotator", "codex-review-debug.log");
+var DEBUG_LOG_PATH = join9(homedir5(), ".plannotator", "codex-review-debug.log");
 async function debugLog(label, data) {
   if (!DEBUG_ENABLED)
     return;
   try {
-    await mkdir(join9(homedir4(), ".plannotator"), { recursive: true });
+    await mkdir(join9(homedir5(), ".plannotator"), { recursive: true });
     const timestamp = new Date().toISOString();
     const line = data !== undefined ? `[${timestamp}] ${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
 ` : `[${timestamp}] ${label}
@@ -44995,7 +45070,7 @@ var CODEX_REVIEW_SCHEMA = JSON.stringify({
   required: ["findings", "overall_correctness", "overall_explanation", "overall_confidence_score"],
   additionalProperties: false
 });
-var SCHEMA_DIR = join9(homedir4(), ".plannotator");
+var SCHEMA_DIR = join9(homedir5(), ".plannotator");
 var SCHEMA_FILE = join9(SCHEMA_DIR, "codex-review-schema.json");
 var schemaMaterialized = false;
 async function ensureSchemaFile() {
@@ -46941,7 +47016,14 @@ async function urlToMarkdown(url, options) {
       return { markdown: text, source: "fetch-raw" };
     }
   }
-  if (options.useJina && !isLocalUrl(url)) {
+  const local = isLocalUrl(url);
+  if (!local) {
+    const negotiated = await fetchViaContentNegotiation(url);
+    if (negotiated !== null) {
+      return { markdown: negotiated, source: "content-negotiation" };
+    }
+  }
+  if (options.useJina && !local) {
     try {
       const markdown2 = await fetchViaJina(url);
       return { markdown: markdown2, source: "jina" };
@@ -47026,6 +47108,45 @@ async function fetchRawText(url) {
     clearTimeout(timer);
   }
 }
+var NEGOTIATION_TIMEOUT_MS = 5000;
+async function fetchViaContentNegotiation(url) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), NEGOTIATION_TIMEOUT_MS);
+  const headers = {
+    "User-Agent": "Mozilla/5.0 (compatible; Plannotator/1.0; +https://plannotator.ai)",
+    Accept: "text/markdown, text/html;q=0.9"
+  };
+  try {
+    let currentUrl = url;
+    let res = await fetch(currentUrl, { headers, redirect: "manual", signal: controller.signal });
+    for (let i3 = 0;i3 < MAX_REDIRECTS && REDIRECT_STATUSES.has(res.status); i3++) {
+      const location = res.headers.get("location");
+      if (!location)
+        break;
+      currentUrl = new URL(location, currentUrl).href;
+      if (isLocalUrl(currentUrl)) {
+        res.body?.cancel();
+        return null;
+      }
+      res.body?.cancel();
+      res = await fetch(currentUrl, { headers, redirect: "manual", signal: controller.signal });
+    }
+    if (!res.ok) {
+      res.body?.cancel();
+      return null;
+    }
+    const ct = res.headers.get("content-type") || "";
+    if (!ct.includes("text/markdown")) {
+      res.body?.cancel();
+      return null;
+    }
+    return await readBodyWithLimit(res);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function fetchViaJina(url) {
   const cleanUrl = url.split("#")[0];
   const jinaUrl = `https://r.jina.ai/${cleanUrl}`;
@@ -47190,7 +47311,7 @@ Please address this feedback.`;
   }
 }
 async function handleAnnotateCommand(event, deps) {
-  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl } = deps;
+  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl, getPasteApiUrl } = deps;
   const filePath = event.properties?.arguments || event.arguments || "";
   if (!filePath) {
     client3.app.log({ level: "error", message: "Usage: /plannotator-annotate <file.md | file.html | https://...>" });
@@ -47214,7 +47335,7 @@ async function handleAnnotateCommand(event, deps) {
     sourceInfo = filePath;
   } else {
     const projectRoot = process.cwd();
-    const resolvedArg = path3.resolve(projectRoot, filePath);
+    const resolvedArg = resolveUserPath(filePath, projectRoot);
     if (/\.html?$/i.test(resolvedArg)) {
       let fileSize;
       try {
@@ -47260,6 +47381,7 @@ ${resolved.matches.map((m3) => `  ${m3}`).join(`
     sourceInfo,
     sharingEnabled: await getSharingEnabled(),
     shareBaseUrl: getShareBaseUrl(),
+    pasteApiUrl: getPasteApiUrl(),
     htmlContent,
     onReady: handleServerReady
   });
@@ -47293,7 +47415,7 @@ Please address the annotation feedback above.`
   }
 }
 async function handleAnnotateLastCommand(event, deps) {
-  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl } = deps;
+  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl, getPasteApiUrl } = deps;
   const sessionId = event.properties?.sessionID;
   if (!sessionId) {
     client3.app.log({ level: "error", message: "No active session." });
@@ -47329,6 +47451,7 @@ async function handleAnnotateLastCommand(event, deps) {
     mode: "annotate-last",
     sharingEnabled: await getSharingEnabled(),
     shareBaseUrl: getShareBaseUrl(),
+    pasteApiUrl: getPasteApiUrl(),
     htmlContent,
     onReady: handleServerReady
   });
@@ -47341,7 +47464,7 @@ async function handleAnnotateLastCommand(event, deps) {
   return result.feedback || null;
 }
 async function handleArchiveCommand(event, deps) {
-  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl } = deps;
+  const { client: client3, htmlContent, getSharingEnabled, getShareBaseUrl, getPasteApiUrl } = deps;
   client3.app.log({ level: "info", message: "Opening plan archive..." });
   const server2 = await startPlannotatorServer({
     plan: "",
@@ -47349,6 +47472,7 @@ async function handleArchiveCommand(event, deps) {
     mode: "archive",
     sharingEnabled: await getSharingEnabled(),
     shareBaseUrl: getShareBaseUrl(),
+    pasteApiUrl: getPasteApiUrl(),
     htmlContent,
     onReady: handleServerReady
   });
@@ -47410,14 +47534,29 @@ if (_proto?.constructor && _proto.constructor !== Response && _proto.constructor
 }
 var _planHtml = null;
 var _reviewHtml = null;
+function resolveBundledHtmlPath(filename) {
+  const candidates = [
+    path4.join(import.meta.dir, filename),
+    path4.join(import.meta.dir, "..", filename)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync10(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not find bundled HTML asset: ${filename}`);
+}
+function readBundledHtml(filename) {
+  return readFileSync6(resolveBundledHtmlPath(filename), "utf-8");
+}
 function getPlanHtml() {
   if (!_planHtml)
-    _planHtml = readFileSync6(path4.join(import.meta.dir, "..", "plannotator.html"), "utf-8");
+    _planHtml = readBundledHtml("plannotator.html");
   return _planHtml;
 }
 function getReviewHtml() {
   if (!_reviewHtml)
-    _reviewHtml = readFileSync6(path4.join(import.meta.dir, "..", "review-editor.html"), "utf-8");
+    _reviewHtml = readBundledHtml("review-editor.html");
   return _reviewHtml;
 }
 var DEFAULT_PLAN_TIMEOUT_SECONDS = 345600;
@@ -47465,10 +47604,10 @@ Only write and submit a plan once you have sufficient context.
 - Don't end your turn without either submitting a plan or asking the user a question.`;
 }
 var PlannotatorPlugin = async (ctx) => {
-  Bun.file(path4.join(import.meta.dir, "..", "plannotator.html")).text().then((h) => {
+  Bun.file(resolveBundledHtmlPath("plannotator.html")).text().then((h) => {
     _planHtml = h;
   });
-  Bun.file(path4.join(import.meta.dir, "..", "review-editor.html")).text().then((h) => {
+  Bun.file(resolveBundledHtmlPath("review-editor.html")).text().then((h) => {
     _reviewHtml = h;
   });
   let cachedAgents = null;
@@ -47485,6 +47624,9 @@ var PlannotatorPlugin = async (ctx) => {
   function getShareBaseUrl() {
     return process.env.PLANNOTATOR_SHARE_URL || undefined;
   }
+  function getPasteApiUrl() {
+    return process.env.PLANNOTATOR_PASTE_URL || undefined;
+  }
   function getPlanTimeoutSeconds() {
     const raw = process.env.PLANNOTATOR_PLAN_TIMEOUT_SECONDS?.trim();
     if (!raw)
@@ -47618,6 +47760,7 @@ Do NOT proceed with implementation until your plan is approved.`);
         reviewHtmlContent: getReviewHtml(),
         getSharingEnabled,
         getShareBaseUrl,
+        getPasteApiUrl,
         directory: ctx.directory
       };
       const feedback = await handleAnnotateLastCommand({ properties: { sessionID: input.sessionID } }, deps);
@@ -47650,6 +47793,7 @@ Please address the annotation feedback above.`
         reviewHtmlContent: getReviewHtml(),
         getSharingEnabled,
         getShareBaseUrl,
+        getPasteApiUrl,
         directory: ctx.directory
       };
       if (commandName === "plannotator-review")
@@ -47684,6 +47828,7 @@ Please address the annotation feedback above.`
             origin: "opencode",
             sharingEnabled,
             shareBaseUrl: getShareBaseUrl(),
+            pasteApiUrl: getPasteApiUrl(),
             htmlContent: getPlanHtml(),
             opencodeClient: ctx.client,
             onReady: async (url, isRemote, port) => {
@@ -47708,11 +47853,6 @@ Please address the annotation feedback above.`
             const shouldSwitchAgent = result.agentSwitch && result.agentSwitch !== "disabled";
             const targetAgent = result.agentSwitch || "build";
             if (shouldSwitchAgent) {
-              try {
-                await ctx.client.tui.executeCommand({
-                  body: { command: "agent_cycle" }
-                });
-              } catch {}
               try {
                 await ctx.client.session.prompt({
                   path: { id: context.sessionID },