@coinseeker/opencode-telegram-plugin 1.1.1 → 1.1.3

package/README.md

@@ -15,14 +15,16 @@ Configure the npm package in `~/.config/opencode/opencode.json`:
 
 ```json
 {
-  "plugin": ["@coinseeker/opencode-telegram-plugin@1.1.1"]
+  "plugin": ["@coinseeker/opencode-telegram-plugin@1.1.3"]
 }
 ```
 
-Current stable version: `@coinseeker/opencode-telegram-plugin@1.1.1`.
+Current stable version: `@coinseeker/opencode-telegram-plugin@1.1.3`.
 
 Restart OpenCode after editing the config. OpenCode resolves npm package plugins on startup.
 
+To update an existing install, replace the previous pinned package entry with `@coinseeker/opencode-telegram-plugin@1.1.3`, keep the rest of the `plugin` array unchanged, and restart OpenCode.
+
 ## Configure Telegram
 
 Create `~/.config/opencode/telegram-remote/.env`:

package/dist/telegram-remote.js

@@ -384,6 +384,8 @@ function parsePending(text) {
     throw new Error("Invalid pending permission: requestID");
   if (typeof parsed.sessionID !== "string")
     throw new Error("Invalid pending permission: sessionID");
+  if (parsed.directory !== void 0 && typeof parsed.directory !== "string")
+    throw new Error("Invalid pending permission: directory");
   if (typeof parsed.title !== "string") throw new Error("Invalid pending permission: title");
   if (typeof parsed.permission !== "string")
     throw new Error("Invalid pending permission: permission");
@@ -537,10 +539,34 @@ function replyLabel(reply) {
   if (reply === "always") return "Always allowed";
   return "Rejected";
 }
+async function upgradeLegacyPendingPermission(permission, ctx) {
+  const found = await ctx.pendingPermissions.findByRequestID(
+    permission.requestID,
+    permission.sessionID,
+    ctx.serverUrl.href
+  );
+  if (!found || found.data.endpoint === "request") return;
+  await ctx.pendingPermissions.savePending(found.shortHash, {
+    ...found.data,
+    directory: ctx.directory,
+    title: permission.title,
+    permission: permission.permission,
+    patterns: permission.patterns,
+    always: permission.always,
+    endpoint: "request"
+  });
+  ctx.logger.info("permission pending upgraded to request endpoint", {
+    requestID: permission.requestID,
+    sessionID: permission.sessionID
+  });
+}
 async function handleNormalizedPermission(permission, ctx) {
   const permissionKey = `${ctx.serverUrl.href}:${permission.sessionID}:${permission.requestID}`;
   const claimed = await claimOnce({ claimsDir: ctx.claimsDir, key: `permission:${permissionKey}` });
-  if (!claimed) return;
+  if (!claimed) {
+    if (permission.endpoint === "request") await upgradeLegacyPendingPermission(permission, ctx);
+    return;
+  }
   const shortHash = createPermissionShortHash(
     permission.requestID,
     permission.sessionID,
@@ -558,6 +584,7 @@ async function handleNormalizedPermission(permission, ctx) {
       requestID: permission.requestID,
       sessionID: permission.sessionID,
       serverUrl: ctx.serverUrl.href,
+      directory: ctx.directory,
       title: permission.title,
       permission: permission.permission,
       patterns: permission.patterns,
@@ -641,7 +668,8 @@ function createPermissionDispatcher(ctx) {
           pending.sessionID,
           reply,
           pending.endpoint,
-          pending.serverUrl
+          pending.serverUrl,
+          pending.directory
         );
         await ctx.bot.editMessageRemoveKeyboard(
           messageId,
@@ -661,7 +689,10 @@ ${pending.permission}: ${pending.title}`
         );
         ctx.logger.error("failed to send permission reply", {
           error: String(err),
-          requestID: pending.requestID
+          requestID: pending.requestID,
+          endpoint: pending.endpoint,
+          serverUrl: pending.serverUrl,
+          directory: pending.directory
         });
       } finally {
         await ctx.pendingPermissions.deletePending(shortHash);
@@ -1560,7 +1591,7 @@ var ROOT_IDLE_RECHECK_DELAY_MS = 2500;
 var DEFERRED_PARENT_CONFIRM_DELAY_MS = 2500;
 var deferredConfirmTimers = /* @__PURE__ */ new Map();
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function agentFinishedMessage(title, agent) {
   const base = title ? `Agent has finished: ${title}` : "Agent has finished.";
@@ -1913,48 +1944,170 @@ ${body}
 
 // src/lib/plan-readiness.ts
 import { access, readFile as readFile5, readdir as readdir6, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
-async function checkPlanReadiness(args) {
-  const { projectRoot } = args;
-  const omoDir = join6(projectRoot, ".omo");
-  const plansDir = join6(omoDir, "plans");
-  const boulderPath = join6(omoDir, "boulder.json");
+import { basename, isAbsolute, join as join6, relative, resolve } from "path";
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeBoulderWork(value) {
+  const record = asRecord2(value);
+  if (!record || typeof record.active_plan !== "string") return void 0;
+  const work = {
+    activePlan: record.active_plan,
+    sessionIds: stringArray(record.session_ids)
+  };
+  const planName = optionalString(record.plan_name);
+  if (planName !== void 0) work.planName = planName;
+  const status = optionalString(record.status);
+  if (status !== void 0) work.status = status;
+  const startedAt = optionalString(record.started_at);
+  if (startedAt !== void 0) work.startedAt = startedAt;
+  const updatedAt = optionalString(record.updated_at);
+  if (updatedAt !== void 0) work.updatedAt = updatedAt;
+  const worktreePath = optionalString(record.worktree_path);
+  if (worktreePath !== void 0) work.worktreePath = worktreePath;
+  return work;
+}
+function normalizeBoulderState(value) {
+  const record = asRecord2(value);
+  if (!record) return void 0;
+  const state = { sessionIds: stringArray(record.session_ids) };
+  const activePlan = optionalString(record.active_plan);
+  if (activePlan !== void 0) state.activePlan = activePlan;
+  const planName = optionalString(record.plan_name);
+  if (planName !== void 0) state.planName = planName;
+  const status = optionalString(record.status);
+  if (status !== void 0) state.status = status;
+  const startedAt = optionalString(record.started_at);
+  if (startedAt !== void 0) state.startedAt = startedAt;
+  const updatedAt = optionalString(record.updated_at);
+  if (updatedAt !== void 0) state.updatedAt = updatedAt;
+  const worktreePath = optionalString(record.worktree_path);
+  if (worktreePath !== void 0) state.worktreePath = worktreePath;
+  const activeWorkId = optionalString(record.active_work_id);
+  if (activeWorkId !== void 0) state.activeWorkId = activeWorkId;
+  const worksRecord = asRecord2(record.works);
+  if (worksRecord) {
+    const works = {};
+    for (const [workId, rawWork] of Object.entries(worksRecord)) {
+      const work = normalizeBoulderWork(rawWork);
+      if (work) works[workId] = work;
+    }
+    if (Object.keys(works).length > 0) state.works = works;
+  }
+  return state;
+}
+async function readBoulderState(boulderPath) {
+  let text;
   try {
-    await access(omoDir);
+    text = await readFile5(boulderPath, "utf8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return { exists: false };
+    }
+    return { exists: true };
+  }
+  try {
+    return { exists: true, state: normalizeBoulderState(JSON.parse(text)) };
   } catch {
-    return {
-      ready: false,
-      reason: "no-omo-dir",
-      detail: `${omoDir} does not exist`
-    };
+    return { exists: true };
   }
+}
+function mirrorWorkFromState(state) {
+  if (!state.activePlan) return void 0;
+  const work = {
+    activePlan: state.activePlan,
+    sessionIds: state.sessionIds
+  };
+  if (state.planName !== void 0) work.planName = state.planName;
+  if (state.status !== void 0) work.status = state.status;
+  if (state.startedAt !== void 0) work.startedAt = state.startedAt;
+  if (state.updatedAt !== void 0) work.updatedAt = state.updatedAt;
+  if (state.worktreePath !== void 0) work.worktreePath = state.worktreePath;
+  return work;
+}
+function boulderWorks(state) {
+  if (state.works) return Object.values(state.works);
+  const mirrorWork = mirrorWorkFromState(state);
+  return mirrorWork ? [mirrorWork] : [];
+}
+function parseIsoToMs(value) {
+  if (!value) return 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? 0 : ms;
+}
+function findBoulderWorkForSession(state, sessionId) {
+  const works = boulderWorks(state).filter((work) => work.sessionIds.includes(sessionId)).sort(
+    (left, right) => parseIsoToMs(right.updatedAt ?? right.startedAt) - parseIsoToMs(left.updatedAt ?? left.startedAt)
+  );
+  if (works[0]) return works[0];
+  const mirrorWork = mirrorWorkFromState(state);
+  if (mirrorWork && state.sessionIds.includes(sessionId)) return mirrorWork;
+  return void 0;
+}
+function isActiveBoulderWork(work) {
+  return work.status !== "completed" && work.status !== "abandoned";
+}
+function resolveTrackedPath(baseDirectory, trackedPath) {
+  return isAbsolute(trackedPath) ? resolve(trackedPath) : resolve(baseDirectory, trackedPath);
+}
+async function resolveBoulderPlanPath(projectRoot, work) {
+  const absolutePlanPath = resolveTrackedPath(projectRoot, work.activePlan);
+  const worktreePath = work.worktreePath?.trim();
+  if (!worktreePath) return absolutePlanPath;
+  const relativePlanPath = relative(resolve(projectRoot), absolutePlanPath);
+  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) {
+    return absolutePlanPath;
+  }
+  const worktreePlanPath = resolve(resolveTrackedPath(projectRoot, worktreePath), relativePlanPath);
   try {
-    await access(boulderPath);
-    return {
-      ready: false,
-      reason: "boulder-active",
-      detail: `${boulderPath} exists`
-    };
+    await access(worktreePlanPath);
+    return worktreePlanPath;
   } catch {
+    return absolutePlanPath;
   }
+}
+function planNameFromPath(planPath) {
+  return basename(planPath, ".md");
+}
+function normalizePlanToken(value) {
+  return value.normalize("NFKD").toLowerCase().replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function selectPlanByHint(candidates, planHint) {
+  if (!planHint) return void 0;
+  const normalizedHint = normalizePlanToken(planHint);
+  if (!normalizedHint) return void 0;
+  return candidates.find((candidate) => {
+    const planName = candidate.name.replace(/\.md$/, "");
+    return normalizePlanToken(planName) === normalizedHint;
+  });
+}
+function resolvePlanPathHint(projectRoot, planPath) {
+  if (!planPath) return void 0;
+  const resolvedPath = isAbsolute(planPath) ? resolve(planPath) : resolve(projectRoot, planPath);
+  const plansRoot = resolve(projectRoot, ".omo", "plans");
+  const relativePlanPath = relative(plansRoot, resolvedPath);
+  if (!resolvedPath.endsWith(".md") || relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) {
+    return void 0;
+  }
+  return resolvedPath;
+}
+async function getPlanFiles(plansDir) {
   let planFiles = [];
   try {
     const entries = await readdir6(plansDir);
     planFiles = entries.filter((e) => e.endsWith(".md"));
   } catch {
-    return {
-      ready: false,
-      reason: "no-plans",
-      detail: `${plansDir} not found or empty`
-    };
-  }
-  if (planFiles.length === 0) {
-    return {
-      ready: false,
-      reason: "no-plans",
-      detail: `No .md files in ${plansDir}`
-    };
+    return void 0;
   }
+  if (planFiles.length === 0) return [];
   const stats = await Promise.all(
     planFiles.map(async (f) => {
       const full = join6(plansDir, f);
@@ -1962,9 +2115,20 @@ async function checkPlanReadiness(args) {
       return { path: full, name: f, mtime: s.mtime.getTime() };
     })
   );
-  stats.sort((a, b) => b.mtime - a.mtime);
-  const latest = stats[0];
-  const content = await readFile5(latest.path, "utf8");
+  return stats.sort((a, b) => b.mtime - a.mtime);
+}
+async function readPlanProgress(planPath, planName, boulderActive = false) {
+  let content;
+  try {
+    content = await readFile5(planPath, "utf8");
+  } catch {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `${planPath} not found`,
+      ...boulderActive ? { boulderActive } : {}
+    };
+  }
   const totalMatches = content.match(/^- \[[ xX]\]/gm) ?? [];
   const completedMatches = content.match(/^- \[[xX]\]/gm) ?? [];
   const total = totalMatches.length;
@@ -1973,24 +2137,99 @@ async function checkPlanReadiness(args) {
     return {
       ready: false,
       reason: "plan-empty",
-      detail: `${latest.name}: no checkboxes found`
+      detail: `${planName}: no checkboxes found`,
+      ...boulderActive ? { boulderActive } : {}
     };
   }
   if (completed >= total) {
     return {
       ready: false,
       reason: "all-plans-complete",
-      detail: `${latest.name}: ${completed}/${total} complete`
+      detail: `${planName}: ${completed}/${total} complete`,
+      ...boulderActive ? { boulderActive } : {}
     };
   }
   return {
     ready: true,
-    planPath: latest.path,
-    planName: latest.name.replace(/\.md$/, ""),
+    planPath,
+    planName,
     total,
-    completed
+    completed,
+    ...boulderActive ? { boulderActive } : {}
   };
 }
+async function checkPlanReadiness(args) {
+  const { projectRoot, sessionId } = args;
+  const allowLatestFallback = args.allowLatestFallback ?? sessionId === void 0;
+  const omoDir = join6(projectRoot, ".omo");
+  const plansDir = join6(omoDir, "plans");
+  const boulderPath = join6(omoDir, "boulder.json");
+  try {
+    await access(omoDir);
+  } catch {
+    return {
+      ready: false,
+      reason: "no-omo-dir",
+      detail: `${omoDir} does not exist`
+    };
+  }
+  const boulder = await readBoulderState(boulderPath);
+  const projectBoulderActive = boulder.exists;
+  if (boulder.exists && sessionId === void 0) {
+    return {
+      ready: false,
+      reason: "boulder-active",
+      detail: `${boulderPath} exists`,
+      boulderActive: true
+    };
+  }
+  if (boulder.state && sessionId !== void 0) {
+    const work = findBoulderWorkForSession(boulder.state, sessionId);
+    if (work) {
+      const planPath = await resolveBoulderPlanPath(projectRoot, work);
+      return readPlanProgress(
+        planPath,
+        work.planName ?? planNameFromPath(planPath),
+        isActiveBoulderWork(work)
+      );
+    }
+  }
+  const explicitPlanPath = resolvePlanPathHint(projectRoot, args.planPath);
+  if (explicitPlanPath) {
+    return readPlanProgress(explicitPlanPath, planNameFromPath(explicitPlanPath), projectBoulderActive);
+  }
+  const stats = await getPlanFiles(plansDir);
+  if (stats === void 0) {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `${plansDir} not found or empty`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  if (stats.length === 0) {
+    return {
+      ready: false,
+      reason: "no-plans",
+      detail: `No .md files in ${plansDir}`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  const hinted = selectPlanByHint(stats, args.planHint);
+  if (hinted) {
+    return readPlanProgress(hinted.path, hinted.name.replace(/\.md$/, ""), projectBoulderActive);
+  }
+  if (!allowLatestFallback) {
+    return {
+      ready: false,
+      reason: "no-session-plan",
+      detail: `No plan associated with session ${sessionId ?? "missing"}`,
+      ...projectBoulderActive ? { boulderActive: true } : {}
+    };
+  }
+  const latest = stats[0];
+  return readPlanProgress(latest.path, latest.name.replace(/\.md$/, ""), projectBoulderActive);
+}
 async function recheckSessionIdle(client, sessionId) {
   const result = await client.session.status();
   const statuses = result.data ?? {};
@@ -2052,6 +2291,8 @@ function planReadinessKorean(result) {
     }
     case "boulder-active":
       return "boulder \uD65C\uC131";
+    case "no-session-plan":
+      return "\uC138\uC158 \uC5F0\uACB0 plan \uC5C6\uC74C";
   }
 }
 function planLine(result) {
@@ -2061,7 +2302,7 @@ function planLine(result) {
   return `<b>\uD50C\uB79C \uC0C1\uD0DC</b>: ${planReadinessKorean(result)}`;
 }
 function boulderLine(result) {
-  const active = !result.ready && result.reason === "boulder-active";
+  const active = result.boulderActive === true || !result.ready && result.reason === "boulder-active";
   return active ? "<b>Boulder</b>: \uD65C\uC131" : "<b>Boulder</b>: \uC5C6\uC74C";
 }
 function createStatusDispatcher(deps) {
@@ -2162,11 +2403,18 @@ function createStatusDispatcher(deps) {
       return;
     }
     const projectRoot = resolveProjectRoot(session);
-    const planReady = await checkPlanReadiness({ projectRoot });
+    const rawTitle = session.title ?? entry.title;
+    const rawAgent = entry.agent ?? session.agent;
+    const planReady = await checkPlanReadiness({
+      projectRoot,
+      sessionId: entry.sessionId,
+      planHint: rawTitle,
+      allowLatestFallback: rawAgent === "plan"
+    });
     const userSnippet = buildSnippet(findLastByRole(messages, "user"));
     const assistantSnippet = buildSnippet(findLastByRole(messages, "assistant"));
-    const title = escapeHtml(session.title ?? "");
-    const agent = entry.agent ? escapeHtml(entry.agent) : "?";
+    const title = escapeHtml(rawTitle ?? "");
+    const agent = rawAgent ? escapeHtml(rawAgent) : "?";
     const text = [
       `<b>\uC138\uC158 #${n}</b>: ${title}`,
       `\uC5D0\uC774\uC804\uD2B8: ${agent}`,
@@ -2208,6 +2456,8 @@ function readinessMessage(reason) {
       return "plan \uC758 \uBAA8\uB4E0 task \uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uC0C8 plan \uC791\uC131 \uD544\uC694";
     case "boulder-active":
       return ".omo/boulder.json \uC774 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uAE30\uC874 \uC791\uC5C5\uC774 \uC9C4\uD589 \uC911\uC774\uAC70\uB098 archive \uAC00 \uD544\uC694\uD569\uB2C8\uB2E4";
+    case "no-session-plan":
+      return "\uD574\uB2F9 \uC138\uC158\uACFC \uC5F0\uACB0\uB41C plan \uC774 \uC5C6\uC2B5\uB2C8\uB2E4";
   }
 }
 function isSessionNotFoundError(err) {
@@ -2878,6 +3128,12 @@ var SessionTitleService = class {
 
 // src/telegram-remote.ts
 var pluginDir = dirname6(fileURLToPath(import.meta.url));
+function withDirectoryQuery(path, directory) {
+  if (directory === void 0) return path;
+  const url = new URL(path, "http://opencode.local");
+  url.searchParams.set("directory", directory);
+  return `${url.pathname}${url.search}`;
+}
 async function postToServer(serverUrl, path, body) {
   const safeServerUrl = normalizeOpenCodeServerUrl(serverUrl);
   if (!safeServerUrl) throw new Error("Invalid OpenCode server URL");
@@ -2950,9 +3206,12 @@ var TelegramRemote = async (input) => {
         throwOnError: true
       });
     };
-    const replyToPermission = async (requestID, sessionID, reply, endpoint2, serverUrl = input.serverUrl.href) => {
+    const replyToPermission = async (requestID, sessionID, reply, endpoint2, serverUrl = input.serverUrl.href, directory = input.directory) => {
       if (endpoint2 === "request") {
-        const path2 = `/permission/${encodeURIComponent(requestID)}/reply`;
+        const path2 = withDirectoryQuery(
+          `/permission/${encodeURIComponent(requestID)}/reply`,
+          directory
+        );
         if (serverUrl !== input.serverUrl.href) {
           await postToServer(serverUrl, path2, { reply });
           return;
@@ -2965,7 +3224,10 @@ var TelegramRemote = async (input) => {
         });
         return;
       }
-      const path = `/session/${encodeURIComponent(sessionID)}/permissions/${encodeURIComponent(requestID)}`;
+      const path = withDirectoryQuery(
+        `/session/${encodeURIComponent(sessionID)}/permissions/${encodeURIComponent(requestID)}`,
+        directory
+      );
       if (serverUrl !== input.serverUrl.href) {
         await postToServer(serverUrl, path, { response: reply });
         return;
@@ -3067,6 +3329,7 @@ var TelegramRemote = async (input) => {
       claimsDir,
       pluginDir,
       serverUrl: input.serverUrl,
+      directory: input.directory,
       tokenHash,
       pendingQuestions,
       pendingPermissions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinseeker/opencode-telegram-plugin",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Control and monitor OpenCode from Telegram with notifications, question replies, and subagent-aware completion.",
   "type": "module",
   "main": "dist/telegram-remote.js",