@programinglive/dev-workflow-mcp-server 1.13.11 → 1.13.13

package/factory-client.js

@@ -25,6 +25,7 @@ import os from "os";
 import { assertSafeKnowledge } from './security/policy.js';
 import { sanitize } from './security/sanitizer.js';
 import { registerRuntimeSecret } from './security/runtime-secrets.js';
+import { refreshFactoryCredentials, describeLoginFailure } from './factory-credentials.js';
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
 
@@ -397,6 +398,27 @@ export function buildWorkFinishPayload({ sessionId, deviceId, outcome, summary,
 // HTTP layer
 // ---------------------------------------------------------------------------
 
+/**
+ * Kapan proses MCP ini hidup.
+ *
+ * Dipakai di pesan gagal login: tanpa ini pengguna tidak punya cara tahu bahwa
+ * environment yang dipakai sudah usang.
+ */
+function processStartedAt() {
+  return new Date(Date.now() - process.uptime() * 1000);
+}
+
+/** Satu percobaan login dengan pasangan email/password tertentu. */
+function attemptLogin(config, fetchImpl, { email, password }) {
+  registerRuntimeSecret(password);
+
+  return fetchImpl(`${config.pocketBaseUrl}/api/collections/activity_users/auth-with-password`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ identity: email, password }),
+  });
+}
+
 async function resolveToken(config, fetchImpl = fetch) {
   registerRuntimeSecret(config.token); registerRuntimeSecret(config.password);
   if (config.token) return config.token;
@@ -405,24 +427,57 @@ async function resolveToken(config, fetchImpl = fetch) {
   const cached = tokenCache.get(key);
   if (cached && cached.expiresAt > Date.now()) return cached.token;
 
-  const response = await fetchImpl(`${config.pocketBaseUrl}/api/collections/activity_users/auth-with-password`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ identity: config.email, password: config.password }),
-  });
+  const remember = (token) => {
+    registerRuntimeSecret(token);
+    tokenCache.set(key, { token, expiresAt: Date.now() + TOKEN_TTL_MS });
+    return token;
+  };
 
-  if (!response.ok) {
-    throw new Error(
-      `Factory login failed (HTTP ${response.status}). Check FACTORY_EMAIL and FACTORY_PASSWORD, or set FACTORY_TOKEN.`,
-    );
+  const response = await attemptLogin(config, fetchImpl, config);
+
+  if (response.ok) {
+    const body = await response.json();
+    if (!body.token) throw new Error("Factory login returned no token.");
+    return remember(body.token);
   }
 
-  const body = await response.json();
-  if (!body.token) throw new Error("Factory login returned no token.");
-  registerRuntimeSecret(body.token);
+  // Kredensial ditolak. Sebelum menyerah, baca ulang berkas konfigurasi: proses
+  // MCP mewarisi environment saat dijalankan dan tidak pernah memuat ulang, jadi
+  // password yang baru diubah di opencode.json tidak pernah terpakai sampai
+  // OpenCode di-restart. 31 Oktober 2026 itu mematikan otomasi berjam-jam.
+  const refreshed = refreshFactoryCredentials(config);
+
+  if (refreshed && refreshed.changed) {
+    if (refreshed.token) {
+      return remember(refreshed.token);
+    }
+
+    if (refreshed.email && refreshed.password) {
+      const retry = await attemptLogin(config, fetchImpl, refreshed);
+
+      if (retry.ok) {
+        const body = await retry.json();
+        if (!body.token) throw new Error("Factory login returned no token.");
+        return remember(body.token);
+      }
+
+      throw new Error(
+        describeLoginFailure({
+          status: retry.status,
+          processStartedAt: processStartedAt(),
+          credentialsChanged: true,
+        }),
+      );
+    }
+  }
 
-  tokenCache.set(key, { token: body.token, expiresAt: Date.now() + TOKEN_TTL_MS });
-  return body.token;
+  throw new Error(
+    describeLoginFailure({
+      status: response.status,
+      processStartedAt: processStartedAt(),
+      credentialsChanged: Boolean(refreshed && refreshed.changed),
+    }),
+  );
 }
 
 /** Test helper: forget cached tokens (for example after a password change). */

package/factory-credentials.js

@@ -0,0 +1,156 @@
+/**
+ * Membaca ulang kredensial Factory dari berkas konfigurasi OpenCode.
+ *
+ * Kenapa perlu: proses MCP mewarisi environment saat ia di-spawn dan tidak
+ * pernah memuat ulang. 31 Oktober 2026 otomasi Factory mati berjam-jam dengan
+ * pesan "login failed (HTTP 400). Check FACTORY_EMAIL and FACTORY_PASSWORD"
+ * padahal password di `~/.config/opencode/opencode.json` sudah benar dan login
+ * langsung ke PocketBase menjawab 200. Penyebabnya: proses MCP hidup sejak
+ * 30 Oktober dan memegang password LAMA di memorinya.
+ *
+ * Modul ini TIDAK menyimpan rahasia baru ke disk. Ia hanya membaca berkas yang
+ * sudah ada dan sudah berisi rahasia itu.
+ */
+
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+
+/** Nama server di blok `mcp` pada konfigurasi OpenCode. */
+export const DEFAULT_SERVER_NAME = "dev-workflow";
+
+/**
+ * Berkas kredensial bawaan: konfigurasi OpenCode.
+ *
+ * Bisa diarahkan lewat `FACTORY_CREDENTIALS_FILE` bila konfigurasinya di tempat
+ * lain (misalnya berkas khusus tanpa isi lain).
+ */
+export function defaultCredentialsFile(env = process.env) {
+  const explicit = clean(env.FACTORY_CREDENTIALS_FILE);
+  if (explicit) return explicit;
+
+  const home = clean(env.HOME) || clean(env.USERPROFILE) || os.homedir();
+  const configHome = clean(env.XDG_CONFIG_HOME) || path.join(home, ".config");
+
+  return path.join(configHome, "opencode", "opencode.json");
+}
+
+function clean(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/**
+ * Mengambil blok `environment` milik server MCP kita dari teks konfigurasi.
+ *
+ * Dua bentuk didukung, karena keduanya ada di lapangan:
+ *   { mcp: { "<nama>": {...} } }            (konfigurasi lama)
+ *   { mcp: { servers: { "<nama>": {...} } } } (konfigurasi OpenCode di mesin ini)
+ *
+ * Mengembalikan null bila teks bukan JSON, tidak punya `mcp`, atau tidak punya
+ * blok server yang diminta. Mengambil server LAIN akan lebih buruk daripada
+ * tidak mengambil apa pun: kredensial proyek lain bisa terpakai.
+ */
+export function extractFactoryEnv(text, { serverName = DEFAULT_SERVER_NAME } = {}) {
+  let parsed;
+
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+
+  const mcp = parsed && parsed.mcp;
+  if (!mcp || typeof mcp !== "object") return null;
+
+  const block = mcp[serverName] || (mcp.servers && mcp.servers[serverName]);
+  if (!block || typeof block !== "object") return null;
+
+  const environment = block.environment;
+  if (!environment || typeof environment !== "object") return null;
+
+  return environment;
+}
+
+/**
+ * Membandingkan kredensial yang sedang dipakai proses dengan yang ada di berkas.
+ *
+ * Mengembalikan null bila tidak ada yang bisa disegarkan (berkas tidak ada,
+ * rusak, atau tanpa blok server kita). Selain itu objek dengan kredensial
+ * TERBARU, plus `changed` yang menandakan apakah ia berbeda dari yang dipakai.
+ */
+export function refreshFactoryCredentials(
+  config = {},
+  { env = process.env, readFileImpl = readFileSync, serverName = DEFAULT_SERVER_NAME } = {}
+) {
+  const file = defaultCredentialsFile(env);
+
+  let text;
+  try {
+    text = String(readFileImpl(file, "utf8"));
+  } catch {
+    return null;
+  }
+
+  const environment = extractFactoryEnv(text, { serverName });
+  if (!environment) return null;
+
+  const token = clean(environment.FACTORY_TOKEN);
+  const email = clean(environment.FACTORY_EMAIL);
+  const password = clean(environment.FACTORY_PASSWORD);
+
+  const current = {
+    token: clean(config.token),
+    email: clean(config.email),
+    password: clean(config.password),
+  };
+
+  const changed =
+    token !== current.token || email !== current.email || password !== current.password;
+
+  return {
+    token,
+    email,
+    password,
+    changed,
+    source: "file",
+    file,
+  };
+}
+
+/**
+ * Pesan gagal login yang bisa ditindaklanjuti.
+ *
+ * Dua hal yang membedakannya dari pesan lama ("check FACTORY_EMAIL and
+ * FACTORY_PASSWORD"): ia menyebut KAPAN proses ini hidup, dan ia menyebut
+ * apakah kredensial di berkas berbeda dari yang sedang dipakai. Tanpa itu,
+ * pengguna disuruh memeriksa password yang sebenarnya sudah benar.
+ */
+export function describeLoginFailure({ status, processStartedAt, credentialsChanged = false }) {
+  const started = processStartedAt instanceof Date ? processStartedAt.toISOString() : "";
+
+  const lines = [
+    `Factory login failed (HTTP ${status}).`,
+    started
+      ? `Proses MCP ini hidup sejak ${started} dan memakai environment yang diwarisi saat itu - ia tidak pernah memuat ulang berkas konfigurasi.`
+      : "Proses MCP ini memakai environment yang diwarisi saat ia dijalankan.",
+  ];
+
+  if (credentialsChanged) {
+    lines.push(
+      "Kredensial di berkas konfigurasi BERBEDA dari yang sedang dipakai proses ini. " +
+        "Kredensial terbaru sudah dicoba dan tetap ditolak, jadi kemungkinan besar " +
+        "password-nya memang salah, atau akunnya belum bisa login."
+    );
+  } else {
+    lines.push(
+      "Kredensial di berkas konfigurasi SAMA dengan yang dipakai, atau berkasnya tidak ditemukan."
+    );
+  }
+
+  lines.push(
+    "Periksa FACTORY_EMAIL/FACTORY_PASSWORD, atau set FACTORY_TOKEN. " +
+      "Bila password baru saja diubah, restart OpenCode agar proses MCP memakai kredensial terbaru."
+  );
+
+  return lines.join(" ");
+}

package/index.js

@@ -13,6 +13,8 @@ import {
   GetPromptRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { fileURLToPath } from "url";
+import path from "path";
+import { acquireProcessLock, releaseProcessLock, lockWarning } from "./process-lock.js";
 import { exec, setActiveProjectDir } from "./exec.js";
 import { normalizeRequestArgs, shellEscape } from "./utils.js";
 import { createGitFacade } from "./git-facade.js";
@@ -197,6 +199,20 @@ export async function main() {
     // Select request metadata before the first disk write. Creating an idle
     // PID fallback here leaves a phantom session alongside the real sessions.
     safeLog('error', `[${new Date().toISOString()}] Workflow state initialization complete.`);
+
+    // Penanda proses: 31 Oktober 2026 dua proses MCP hidup bersamaan dan
+    // memegang kredensial Factory yang berbeda, sehingga tool yang sama
+    // menjawab berbeda tergantung proses mana yang melayaninya. Proses lain
+    // TIDAK dibunuh (itu berbahaya); cukup dilaporkan supaya pengguna tahu
+    // harus menutup OpenCode dan membukanya lagi.
+    try {
+      const stateDir = path.dirname(path.resolve(workflowState.stateFile));
+      const warning = lockWarning(acquireProcessLock({ dir: stateDir }));
+      if (warning) safeLog('error', warning);
+      process.once('exit', () => releaseProcessLock({ dir: stateDir }));
+    } catch (lockError) {
+      safeLog('error', 'Warning: could not record process lock:', lockError.message);
+    }
   } catch (error) {
     safeLog('error', `[${new Date().toISOString()}] Warning: Failed to initialize workflow state:`, error.message);
     // Continue anyway - workflow state is optional for MCP to function

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.13.11",
+  "version": "1.13.13",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",

package/process-lock.js

@@ -0,0 +1,134 @@
+/**
+ * Satu penanda "proses MCP mana yang sedang hidup" per direktori state.
+ *
+ * Kenapa perlu: 31 Oktober 2026 ada DUA proses dev-workflow MCP hidup
+ * bersamaan. Yang lebih tua memegang password Factory lama di memorinya, yang
+ * lebih muda memegang yang baru, jadi tool yang sama menjawab berbeda
+ * tergantung proses mana yang melayaninya - dan keduanya menulis berkas state
+ * workflow yang sama.
+ *
+ * Modul ini TIDAK membunuh proses lain. Membunuh proses secara otomatis adalah
+ * tindakan berbahaya (ada guard tersendiri untuk itu). Yang dilakukan: proses
+ * kedua mengetahui bahwa ia bukan satu-satunya, lalu melaporkannya, sehingga
+ * pengguna bisa menutup OpenCode dan memulai ulang dengan bersih.
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import os from "os";
+import path from "path";
+
+export const LOCK_FILENAME = "mcp-process.lock";
+
+/** Lokasi berkas lock untuk satu direktori state. */
+export function processLockPath({ dir }) {
+  return path.join(dir, LOCK_FILENAME);
+}
+
+/**
+ * Membaca isi lock, atau null bila tidak ada / tidak terbaca.
+ *
+ * Berkas rusak sengaja dianggap "tidak ada lock": penanda yang tidak bisa
+ * dibaca tidak boleh membuat server gagal start. Lebih baik dua proses
+ * bertabrakan daripada server tidak hidup sama sekali.
+ */
+export function readProcessLock({ dir }) {
+  const file = processLockPath({ dir });
+
+  if (!existsSync(file)) return null;
+
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (!parsed || typeof parsed.pid !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function defaultIsAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+
+  try {
+    // Sinyal 0 tidak mengirim apa pun; ia hanya memeriksa apakah proses ada.
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM berarti proses ADA tetapi milik pengguna lain.
+    return error && error.code === "EPERM";
+  }
+}
+
+/**
+ * Mencoba menjadi pemegang lock.
+ *
+ * Mengembalikan:
+ *   { acquired: true }                        -> kita pemegangnya
+ *   { acquired: true, tookOverFrom: <pid> }   -> pemegang lama sudah mati
+ *   { acquired: false, holder: {...} }        -> ada proses lain yang hidup
+ */
+export function acquireProcessLock({ dir, pid = process.pid, now = Date.now(), isAlive = defaultIsAlive }) {
+  const existing = readProcessLock({ dir });
+
+  if (existing && existing.pid !== pid && isAlive(existing.pid)) {
+    return { acquired: false, holder: existing };
+  }
+
+  const tookOverFrom = existing && existing.pid !== pid ? existing.pid : undefined;
+
+  const payload = { pid, startedAt: now, host: safeHostname() };
+
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(processLockPath({ dir }), JSON.stringify(payload), "utf8");
+  } catch {
+    // Tidak bisa menulis penanda bukan alasan mematikan server.
+    return { acquired: true, wrote: false };
+  }
+
+  return tookOverFrom ? { acquired: true, tookOverFrom } : { acquired: true };
+}
+
+/** Melepas lock hanya bila memang milik kita. */
+export function releaseProcessLock({ dir, pid = process.pid }) {
+  const existing = readProcessLock({ dir });
+
+  if (!existing || existing.pid !== pid) return false;
+
+  try {
+    unlinkSync(processLockPath({ dir }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function safeHostname() {
+  try {
+    return os.hostname();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Pesan yang dicatat saat proses lain sudah memegang lock, atau null bila tidak
+ * ada yang perlu dilaporkan.
+ *
+ * Dipisah dari `acquireProcessLock` supaya bisa diuji tanpa menyentuh proses
+ * nyata, dan supaya pemanggil bebas memilih tidak menampilkan apa pun.
+ */
+export function lockWarning(result) {
+  if (!result || result.acquired !== false || !result.holder) return null;
+
+  const started = Number.isFinite(result.holder.startedAt)
+    ? new Date(result.holder.startedAt).toISOString()
+    : "waktu tidak diketahui";
+
+  return (
+    `Proses dev-workflow MCP lain (PID ${result.holder.pid}, hidup sejak ${started}) ` +
+    "masih berjalan dan memakai direktori state yang sama. " +
+    "Proses yang lebih tua memegang environment saat ia dijalankan, jadi kredensial Factory " +
+    "dan state workflow bisa berbeda antar proses. Tutup OpenCode lalu buka lagi untuk " +
+    "memastikan hanya satu proses yang hidup."
+  );
+}

package/workflow-state.js

@@ -33,6 +33,22 @@ let cachedUserStateDir = null;
  */
 const PROCESS_TOKEN = `proc-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
 
+/**
+ * Langkah workflow yang hanya boleh MAJU dalam satu task.
+ *
+ * Hanya flag PENCAPAIAN. Gerbang kualitas (`readyToCommit`,
+ * `readyCheckCompleted`, `commitAndPushCompleted`, `released`) SENGAJA tidak
+ * masuk: keempatnya direset ketika langkah sebelumnya diulang, dan memaksa
+ * nilainya tetap true akan melemahkan gerbang yang justru ingin ditegakkan.
+ */
+const MONOTONIC_STEP_FIELDS = [
+  "featureFlowCreated",
+  "bugFixed",
+  "testsCreated",
+  "testsPassed",
+  "documentationCreated",
+];
+
 function migrateOwnerMetadata(value) {
   if(value?.owner && !value.owner.processMarker && /^proc-[A-Za-z0-9-]+$/.test(value.owner.token || '')) {
     value.owner.processMarker=value.owner.token;
@@ -820,6 +836,44 @@ export class WorkflowState {
     return created;
   }
 
+  /**
+   * Gabungkan kemajuan langkah dari disk bila task-nya sama.
+   *
+   * Hanya menyentuh flag yang MONOTON dalam satu task. Field yang bisa turun
+   * dengan sengaja (mis. `readyCheckCompleted` yang direset `create_tests`)
+   * tidak digabung, karena itu bagian dari alur normal satu proses.
+   *
+   * `reconciled` sudah memuat state disk terbaru; `this.state` adalah milik
+   * proses ini. Kalau task berbeda atau disk idle, tidak ada yang digabung:
+   * itu task lain, atau task baru yang memang harus mulai dari nol.
+   */
+  mergeMonotonicProgress(reconciled) {
+    const diskTask = (reconciled?.diskTask || "").trim();
+    const ourTask = (this.state.taskDescription || "").trim();
+    if (!diskTask || !ourTask || diskTask !== ourTask) {
+      return;
+    }
+    if ((reconciled?.diskPhase || "idle") === "idle") {
+      return;
+    }
+
+    // Harus dari `reconciled` yang BARU dibaca. `lastReconcile` adalah hasil
+    // penyimpanan sebelumnya, sehingga bisa tertinggal satu putaran - dan
+    // justru itu yang membuat penggabungan gagal menangkap langkah terbaru.
+    const disk = reconciled?.diskState;
+    if (!disk) {
+      return;
+    }
+
+    // Kemajuan hanya boleh maju. Sekali sebuah langkah tercapai di proses mana
+    // pun, langkah itu tetap tercapai.
+    for (const field of MONOTONIC_STEP_FIELDS) {
+      if (disk[field] === true && this.state[field] !== true) {
+        this.state[field] = true;
+      }
+    }
+  }
+
   async save(options = {}) {
     assertSafeKnowledge(this.state);
     const reconciled = await this.reconcileWithDisk();
@@ -839,6 +893,19 @@ export class WorkflowState {
     }
     this.lastConflict = null;
 
+    // Dua proses MCP bisa melayani sesi yang SAMA (OpenCode men-spawn lebih dari
+    // satu instance), dan keduanya menulis berkas state yang sama. Tanpa ini,
+    // proses yang memegang state basi menimpa langkah yang sudah dicapai proses
+    // lain: `mark_bug_fixed` menjawab sukses, lalu `create_tests` menjawab
+    // "mark your feature/bug as fixed first". Gejalanya intermiten, sehingga
+    // mudah disalahkan pada hal lain.
+    //
+    // Langkah workflow bersifat monoton dalam satu task: sekali tercapai, tidak
+    // boleh mundur. Karena itu digabung dengan OR - tetapi HANYA bila task di
+    // disk memang task yang sama. `start_task` mengganti task, dan pada saat itu
+    // flag harus benar-benar direset, bukan dihidupkan kembali.
+    this.mergeMonotonicProgress(reconciled);
+
     this.state.owner = {
       processMarker: PROCESS_TOKEN,
       pid: process.pid,
@@ -988,11 +1055,15 @@ export class WorkflowState {
       foreignToken: null,
       diskTask: "",
       diskPhase: "idle",
+      // Dipakai mergeMonotonicProgress: state disk apa adanya, supaya flag
+      // langkah yang sudah dicapai proses lain bisa digabung.
+      diskState: null,
     };
     const disk = await this.readDiskState();
     if (!disk) {
       return result;
     }
+    result.diskState = disk;
 
     result.diskTask = disk.taskDescription || "";
     result.diskPhase = disk.currentPhase || "idle";