@programinglive/dev-workflow-mcp-server 1.13.12 → 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.12",
+  "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."
+  );
+}