@programinglive/dev-workflow-mcp-server 1.12.0 → 1.13.0

package/workflow-state.js

@@ -1,6 +1,9 @@
+import { safeLog } from './security/sanitizer.js';
 import fs from "fs/promises";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import path from "path";
+import { assertSafeKnowledge } from './security/policy.js';
+import { sanitize } from './security/sanitizer.js';
 import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -30,6 +33,14 @@ let cachedUserStateDir = null;
  */
 const PROCESS_TOKEN = `proc-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
 
+function migrateOwnerMetadata(value) {
+  if(value?.owner && !value.owner.processMarker && /^proc-[A-Za-z0-9-]+$/.test(value.owner.token || '')) {
+    value.owner.processMarker=value.owner.token;
+    delete value.owner.token;
+  }
+  return value;
+}
+
 function generateUserId() {
   const timestamp = Date.now().toString(16);
   const randomSuffix = Math.random().toString(16).slice(2, 10);
@@ -249,6 +260,8 @@ async function migrateLegacyStateFile(targetPath) {
   }
 
   await fs.mkdir(stateDir, { recursive: true });
+  const migrated = migrateOwnerMetadata(JSON.parse(await fs.readFile(legacyPath, 'utf8')));
+  assertSafeKnowledge(migrated);
 
   try {
     await fs.access(targetPath);
@@ -258,7 +271,8 @@ async function migrateLegacyStateFile(targetPath) {
     // New state file doesn't exist yet; fall through to migrate.
   }
 
-  await fs.rename(legacyPath, targetPath);
+  await fs.writeFile(targetPath, JSON.stringify(migrated, null, 2), { flag: 'wx' });
+  await fs.unlink(legacyPath);
 }
 
 function isRootPath(candidate) {
@@ -338,6 +352,7 @@ async function ensureCompatibilityLinks(primaryPath) {
   if (!(await pathExists(resolvedPrimary))) {
     return;
   }
+  assertSafeKnowledge(JSON.parse(await fs.readFile(resolvedPrimary, 'utf8')));
 
   const compatibilityPaths = getCompatibilityPaths(resolvedPrimary);
 
@@ -413,18 +428,38 @@ async function ensureCompatibilityLinks(primaryPath) {
  *
  * MENGAPA ADA
  * -----------
- * Berkas state dulu disimpan per USER, jadi empat proses MCP berbagi satu
+ * Berkas state dulu disimpan per USER, jadi beberapa proses MCP berbagi satu
  * `workflow-state.json`. Akibatnya `start_task` di satu sesi mengganti task
  * sesi lain di tengah jalan, dan gerbang kualitas (ready check, tests, docs)
  * ikut dibagi sehingga sesi B bisa memakai hasil sesi A untuk commit.
  *
  * Sekarang task dan gerbangnya milik SESI; `history` tetap milik PROYEK.
  *
- * Urutannya sengaja: env eksplisit dulu (untuk tes dan pemanggil lain), lalu
- * id sesi editor, lalu proses. Jatuh ke proses membuat identitas tetap stabil
- * walau modul di-reload dalam proses yang sama.
+ * MENGAPA BUKAN ENV SAJA
+ * ----------------------
+ * Percobaan pertama membaca `OPENCODE_SESSION_ID` dari environment. OpenCode
+ * tidak men-set variabel itu, sehingga hampir semua berkas jatuh ke
+ * `pid-<pid>`; karena satu proses MCP dipakai bergantian oleh beberapa sesi,
+ * sesi-sesi itu tetap berbagi satu berkas dan saling menimpa.
+ *
+ * OpenCode v2 mengirim identitas sesi per panggilan di
+ * `CallToolRequest.params._meta["ai.opencode/sessionID"]`. Itu sumber utama
+ * sekarang; env tetap dibaca sebagai cadangan untuk tes dan pemanggil lain.
  */
-export function resolveSessionKey(env = process.env) {
+export const SESSION_META_KEY = "ai.opencode/sessionID";
+
+/** Mengambil identitas sesi dari request metadata MCP, atau null. */
+export function sessionKeyFromRequest(request) {
+  const value = request?.params?._meta?.[SESSION_META_KEY];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+
+export function resolveSessionKey(env = process.env, explicitSessionId = null) {
+  const fromRequest = typeof explicitSessionId === "string" ? explicitSessionId.trim() : "";
+  if (fromRequest) return sanitizeSessionKey(fromRequest);
+
   for (const candidate of [env.DEV_WORKFLOW_SESSION_ID, env.OPENCODE_SESSION_ID, env.CLIENT_SESSION_ID]) {
     const value = typeof candidate === "string" ? candidate.trim() : "";
     if (value) return sanitizeSessionKey(value);
@@ -438,8 +473,8 @@ function sanitizeSessionKey(value) {
 }
 
 /** Nama berkas state untuk sesi ini, di direktori user yang sama. */
-function sessionStateFilename(env = process.env) {
-  return `workflow-state.${resolveSessionKey(env)}.json`;
+function sessionStateFilename(env = process.env, explicitSessionId = null) {
+  return `workflow-state.${resolveSessionKey(env, explicitSessionId)}.json`;
 }
 
 /**
@@ -457,7 +492,36 @@ export function resolveHistoryFile(stateFilePath) {
   return inUserTree ? path.join(dir, STATE_FILENAME) : resolved;
 }
 
-export function resolveStateFile() {
+/**
+ * Induk direktori `.state` untuk sebuah berkas state.
+ *
+ * Dulu ini dihitung dengan empat `dirname` berurutan, yang hanya benar selama
+ * tata letaknya tepat `<root>/.state/users/<user>/<berkas>`. Begitu kedalaman
+ * berubah (mis. state sesi ditaruh di subdirektori), angka itu diam-diam
+ * menghasilkan root yang salah dan baris database tercatat di proyek lain.
+ *
+ * Sekarang dicari dengan sengaja: naik sampai menemukan direktori `.state`,
+ * lalu ambil induknya. Tidak bergantung pada kedalaman.
+ */
+export function resolveProjectRootForState(stateFilePath) {
+  const resolved = path.resolve(stateFilePath);
+  let current = path.dirname(resolved);
+
+  for (;;) {
+    if (path.basename(current) === STATE_DIR) {
+      return path.dirname(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  // Di luar tata letak `.state` (mis. path eksplisit untuk tes): pakai
+  // direktori yang memuat berkasnya.
+  return path.dirname(resolved);
+}
+
+export function resolveStateFile({ sessionId = null } = {}) {
   const customPath = process.env.DEV_WORKFLOW_STATE_FILE;
   if (customPath) {
     return path.resolve(customPath);
@@ -487,7 +551,7 @@ export function resolveStateFile() {
 
   const stateDir = path.join(projectRoot, STATE_DIR);
   const userDir = getUserScopedDir(stateDir);
-  return path.join(userDir, sessionStateFilename());
+  return path.join(userDir, sessionStateFilename(process.env, sessionId));
 }
 
 export class WorkflowState {
@@ -498,6 +562,7 @@ export class WorkflowState {
     this.historyFile = resolveHistoryFile(stateFilePath);
     this.state = {
       currentPhase: "idle",
+      classification: "INTERNAL",
       taskDescription: "",
       bugFixed: false,
       testsCreated: false,
@@ -522,11 +587,54 @@ export class WorkflowState {
     };
   }
 
+  /**
+   * Berpindah ke state milik sesi tertentu.
+   *
+   * Satu proses MCP bisa melayani beberapa sesi bergantian, jadi state harus
+   * ditentukan per panggilan - bukan sekali saat proses start. Mengembalikan
+   * true bila berkas benar-benar berpindah.
+   */
+  async useSession(sessionId) {
+    const target = resolveStateFile({ sessionId });
+    if (target === this.stateFile) return false;
+
+    this.stateFile = target;
+    this.historyFile = resolveHistoryFile(target);
+    // Mulai dari state bersih, lalu muat milik sesi itu. Menyalin state sesi
+    // sebelumnya akan membuat sesi baru mewarisi gerbang kualitas sesi lain.
+    this.state = {
+      currentPhase: "idle",
+      taskDescription: "",
+      bugFixed: false,
+      testsCreated: false,
+      testsPassed: false,
+      testsSkipped: false,
+      testsSkippedReason: "",
+      documentationCreated: false,
+      readyToCommit: false,
+      readyCheckCompleted: false,
+      released: false,
+      releaseSkipped: false,
+      releaseSkippedReason: "",
+      releaseCommand: "",
+      releaseNotes: "",
+      commitAndPushCompleted: false,
+      lastCommitMessage: "",
+      lastPushBranch: "",
+      featureFlowCreated: false,
+      featureFlowDescription: "",
+      history: [],
+      taskType: "",
+    };
+    await this.load();
+    return true;
+  }
+
   async load() {
     await migrateLegacyStateFile(this.stateFile);
     try {
       const data = await fs.readFile(this.stateFile, "utf-8");
-      const parsed = JSON.parse(data);
+      const parsed = sanitize(migrateOwnerMetadata(JSON.parse(data)));
       this.state = {
         ...this.state,
         ...parsed,
@@ -634,11 +742,14 @@ export class WorkflowState {
       }
     }
 
+    const payload = { ...shared, history: merged };
+    assertSafeKnowledge(payload);
     await fs.mkdir(path.dirname(this.historyFile), { recursive: true });
-    await fs.writeFile(this.historyFile, JSON.stringify({ ...shared, history: merged }, null, 2));
+    await fs.writeFile(this.historyFile, JSON.stringify(payload, null, 2));
   }
 
   async ensurePrimaryFile() {
+    assertSafeKnowledge(this.state);
     let created = false;
     try {
       await fs.access(this.stateFile);
@@ -656,9 +767,11 @@ export class WorkflowState {
   }
 
   async save() {
+    assertSafeKnowledge(this.state);
     const reconciled = await this.reconcileWithDisk();
+    assertSafeKnowledge(this.state);
     this.state.owner = {
-      token: PROCESS_TOKEN,
+      processMarker: PROCESS_TOKEN,
       pid: process.pid,
       updatedAt: new Date().toISOString(),
     };
@@ -680,7 +793,7 @@ export class WorkflowState {
   async readDiskState() {
     try {
       const data = await fs.readFile(this.stateFile, "utf-8");
-      return JSON.parse(data);
+      return sanitize(migrateOwnerMetadata(JSON.parse(data)));
     } catch {
       return null;
     }
@@ -688,7 +801,7 @@ export class WorkflowState {
 
   /** True kalau berkas di disk terakhir ditulis proses MCP lain. */
   isForeignWrite(diskState) {
-    const token = diskState?.owner?.token;
+    const token = diskState?.owner?.processMarker;
     return typeof token === "string" && token.length > 0 && token !== PROCESS_TOKEN;
   }
 
@@ -739,7 +852,7 @@ export class WorkflowState {
       return result;
     }
 
-    result.foreignToken = disk.owner.token;
+    result.foreignToken = disk.owner.processMarker;
 
     const hasRunningTask =
       typeof disk.taskDescription === "string" &&
@@ -759,6 +872,7 @@ export class WorkflowState {
     }
 
     this.state.history.push({
+      classification: disk.classification || "INTERNAL",
       taskDescription: disk.taskDescription,
       taskType: disk.taskType || "other",
       commitMessage: disk.lastCommitMessage || "",
@@ -767,7 +881,7 @@ export class WorkflowState {
       dropReason:
         "Ditimpa proses agen lain: state workflow dipakai bersama antar sesi di mesin ini",
       interruptedAtPhase: disk.currentPhase,
-      interruptedBy: disk.owner.token,
+      interruptedBy: disk.owner.processMarker,
       timestamp: new Date().toISOString(),
     });
     result.preservedTask = disk.taskDescription;
@@ -775,40 +889,23 @@ export class WorkflowState {
   }
 
   async updateProjectSummary() {
+    assertSafeKnowledge(this.state);
     const summaryPath = path.join(path.dirname(this.stateFile), PROJECT_SUMMARY_FILENAME);
     const summary = this.generateProjectSummaryData();
+    assertSafeKnowledge(summary);
     await fs.mkdir(path.dirname(summaryPath), { recursive: true });
     await fs.writeFile(summaryPath, JSON.stringify(summary, null, 2));
   }
 
   async syncToDatabase() {
+    assertSafeKnowledge(this.state);
     try {
       const { insertHistoryEntry, updateSummaryForUser, saveState } = await import("./db/index.js");
       const userId = getCurrentUserId();
-      // Use the project directory (parent of .state) as the project identifier
-      // this.stateFile is .../.state/users/<user>/workflow-state.json
-      // so we want resolution logic. For now, let's use the absolute path to the project root.
-      // We can derive it from stateFile path logic in resolveStateFile or just use the directory we are in.
-      // A safe bet that is unique per project on this machine is the project root found by resolveStateFile.
-      // Let's perform a simple resolution:
-
-      const stateDir = path.dirname(path.dirname(path.dirname(this.stateFile)));
-      // stateFile = <root>/.state/users/<user>/workflow-state.json
-      // dirname = <root>/.state/users/<user>
-      // dirname = <root>/.state/users
-      // dirname = <root>/.state
-      // dirname = <root>
-
-      // Wait, let's look at the path structure from resolveStateFile:
-      // path.join(userDir, STATE_FILENAME); where userDir is path.join(stateDir, "users", userId);
-      // and stateDir is path.join(projectRoot, STATE_DIR);
-      // So: projectRoot/.state/users/userId/workflow-state.json
-      // 1. dirname -> .../userId
-      // 2. dirname -> .../users
-      // 3. dirname -> .../.state
-      // 4. dirname -> .../projectRoot
-
-      const projectRoot = path.dirname(path.dirname(path.dirname(path.dirname(this.stateFile))));
+      // projectRoot dipakai sebagai identitas proyek di database. Ditentukan
+      // lewat resolveProjectRootForState, bukan dengan menghitung `dirname`
+      // berkali-kali: jumlah itu hanya benar untuk satu kedalaman tertentu.
+      const projectRoot = resolveProjectRootForState(this.stateFile);
 
       for (const entry of this.state.history || []) {
         await insertHistoryEntry(userId, projectRoot, entry);
@@ -817,7 +914,7 @@ export class WorkflowState {
       await saveState(userId, projectRoot, this.state);
     } catch (error) {
       // Database sync failed; log it but don't crash
-      console.error("Database sync failed:", error.message);
+      safeLog('error', "Database sync failed:", error.message);
     }
   }
 
@@ -883,6 +980,7 @@ export class WorkflowState {
     if (archive && hasRunningTask) {
       archivedTask = previous.taskDescription;
       history.push({
+        classification: previous.classification || "INTERNAL",
         taskDescription: previous.taskDescription,
         taskType: previous.taskType || "other",
         commitMessage: previous.lastCommitMessage || "",
@@ -897,6 +995,7 @@ export class WorkflowState {
 
     this.state = {
       currentPhase: "idle",
+      classification: "INTERNAL",
       taskDescription: "",
       bugFixed: false,
       testsCreated: false,
@@ -925,6 +1024,7 @@ export class WorkflowState {
 
   addToHistory(entry) {
     this.state.history.push({
+      classification: this.state.classification || "INTERNAL",
       ...entry,
       timestamp: new Date().toISOString(),
     });