@programinglive/dev-workflow-mcp-server 1.9.1 → 1.10.0

package/tools/handler-modules/factory-handlers.js

@@ -0,0 +1,276 @@
+import { textResponse } from "./shared.js";
+import {
+  readFactoryConfig,
+  listTasks,
+  findTask,
+  claimTask,
+  updateTaskStatus,
+  createTask,
+  listProjects,
+  formatTaskList,
+  formatProjectList,
+  planStatusTransition,
+} from "../../factory-client.js";
+
+/**
+ * Factory tools stay inert unless a Factory URL and credentials are set.
+ * That keeps the MCP server usable on machines without Factory access.
+ */
+function requireConfig() {
+  const config = readFactoryConfig();
+  if (!config) {
+    return {
+      config: null,
+      response: textResponse(
+        [
+          "Factory is not configured on this machine.",
+          "",
+          "Set these environment variables where the MCP server is launched:",
+          "  FACTORY_URL=https://factory.programinglive.com",
+          "  FACTORY_TOKEN=<PocketBase activity_users token>",
+          "",
+          "Or let the client log in for you:",
+          "  FACTORY_EMAIL=<activity_users email>",
+          "  FACTORY_PASSWORD=<password>",
+          "",
+          "Optional:",
+          "  FACTORY_PB_URL=<PocketBase base URL, default https://pocketbase.programinglive.com>",
+          "  FACTORY_MACHINE_ID=<name shown on the device row>",
+          "  FACTORY_DEVICE_ID=<fixed device UUID>",
+        ].join("\n"),
+      ),
+    };
+  }
+  return { config, response: null };
+}
+
+export async function handleListFactoryTasks(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const statuses = Array.isArray(args.statuses) && args.statuses.length ? args.statuses : undefined;
+  const project = typeof args.project === "string" && args.project.trim() ? args.project.trim() : null;
+  const limit = Number.isFinite(args.limit) ? Math.min(Math.max(args.limit, 1), 200) : 50;
+
+  try {
+    const tasks = await listTasks(config, { statuses, project, limit });
+    return textResponse(formatTaskList(tasks));
+  } catch (error) {
+    return textResponse(`Could not read the Factory queue: ${error.message}`);
+  }
+}
+
+/**
+ * Formats how long ago a work session was last seen.
+ *
+ * Returns an empty string when the timestamp is missing or unparsable, so the
+ * caller can leave that part of the message out instead of printing garbage.
+ */
+function formatLastSeen(value) {
+  if (!value) return "";
+  const seen = Date.parse(value);
+  if (Number.isNaN(seen)) return "";
+  const minutes = Math.floor((Date.now() - seen) / 60000);
+  if (minutes < 1) return "baru saja";
+  if (minutes < 60) return `${minutes} menit lalu`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} jam lalu`;
+  return `${Math.floor(hours / 24)} hari lalu`;
+}
+
+/**
+ * Builds the message shown when Factory refuses a claim because another device
+ * still holds the task.
+ *
+ * The refusal is actionable: it names the holder and shows the exact call to
+ * make, so the agent does not have to guess which parameter is missing.
+ */
+function takeoverRequiredMessage(title, holder = {}) {
+  const seen = formatLastSeen(holder.lastSeenAt);
+  const holderText = [holder.deviceName, holder.agent].filter(Boolean).join(" (") + (holder.agent ? ")" : "");
+  return [
+    `"${title}" sedang dikerjakan oleh perangkat lain.`,
+    "",
+    holderText ? `Pemegang sesi: ${holderText}${seen ? `, terakhir terlihat ${seen}` : ""}.` : "",
+    "",
+    "Ambil alih dengan menyertakan alasan (3-500 karakter):",
+    `  claim_factory_task { "recordId": "<id>", "step": "<langkah>", "takeoverReason": "<alasanmu>" }`,
+    "",
+    "Alasannya dicatat di papan, jadi orang berikutnya tahu kenapa pekerjaan berpindah tangan.",
+  ]
+    .filter((line) => line !== "")
+    .join("\n");
+}
+
+export async function handleClaimFactoryTask(args = {}, { workflowState } = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const recordId = typeof args.recordId === "string" ? args.recordId.trim() : "";
+  if (!recordId) {
+    return textResponse("Provide the 'recordId' of the task to claim (see list_factory_tasks).");
+  }
+
+  const takeoverReason = typeof args.takeoverReason === "string" ? args.takeoverReason.trim() : "";
+  // Judul diambil di luar try supaya pesan penolakan tetap menyebut task yang
+  // sebenarnya, bukan teks umum.
+  let taskTitle = "Task ini";
+
+  try {
+    const task = await findTask(config, recordId);
+    if (!task) {
+      return textResponse(`No task with id "${recordId}" is visible to this account.`);
+    }
+    taskTitle = task.title;
+
+    const step = typeof args.step === "string" && args.step.trim() ? args.step.trim() : "Working on the task";
+    const session = await claimTask(config, { recordId, step, takeoverReason });
+    if (!session) throw new Error("Factory accepted the claim but returned no work session.");
+
+    if (workflowState) {
+      workflowState.reset();
+      workflowState.state.currentPhase = "coding";
+      workflowState.state.taskDescription = `[${task.taskKey || task.id}] ${task.title}`;
+      workflowState.state.taskType = "other";
+      await workflowState.save();
+    }
+
+    return textResponse(
+      [
+        `Claimed [${task.taskKey || task.id}] ${task.title}`,
+        `Factory status is now running (work session ${session.id}).`,
+        task.projectName ? `Project: ${task.projectName}` : "",
+        "",
+        "Local workflow started for this task.",
+        "Use 'sync_task_status' with review, blocked or paused to close the session, or done to approve the task once it is in review.",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    // Factory menolak take over tanpa alasan. Balas dengan arahan yang bisa
+    // dijalankan, bukan dengan pesan error mentah.
+    if (error?.body?.takeoverRequired) {
+      return textResponse(takeoverRequiredMessage(taskTitle, error.body.holder));
+    }
+    return textResponse(`Could not claim the task: ${error.message}`);
+  }
+}
+
+export async function handleSyncTaskStatus(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const recordId = typeof args.recordId === "string" ? args.recordId.trim() : "";
+  const status = typeof args.status === "string" ? args.status.trim() : "";
+  const reason = typeof args.reason === "string" ? args.reason : null;
+  const nextAction = typeof args.nextAction === "string" ? args.nextAction : null;
+
+  if (!recordId) {
+    return textResponse("Provide the 'recordId' of the task to update.");
+  }
+  if (!status) {
+    return textResponse("Provide 'status'. Factory accepts: backlog, queued, review, blocked, paused, cancelled, done.");
+  }
+  if (status === "blocked" && !reason) {
+    return textResponse("Marking a task blocked requires a 'reason' so the next person knows what is missing.");
+  }
+
+  // Validate locally so the agent gets an actionable message instead of a
+  // transport error from Factory.
+  try {
+    planStatusTransition(status);
+  } catch (error) {
+    return textResponse(error.message);
+  }
+
+  try {
+    const result = await updateTaskStatus(config, { recordId, status, reason, nextAction });
+
+    return textResponse(
+      [
+        `Updated ${recordId} to ${result.status}.`,
+        result.session?.summary ? `Summary: ${result.session.summary}` : "",
+        result.status === "review" ? "Waiting for human approval in Factory." : "",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    return textResponse(`Could not update the task: ${error.message}`);
+  }
+}
+
+/**
+ * Lists projects, because create_task needs a real projectId (UUID) and the
+ * agent cannot invent one.
+ */
+export async function handleListFactoryProjects() {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  try {
+    const projects = await listProjects(config);
+    return textResponse(formatProjectList(projects));
+  } catch (error) {
+    return textResponse(`Could not read the Factory projects: ${error.message}`);
+  }
+}
+
+/**
+ * Creates a task on the board through the official write path.
+ *
+ * Defaults to `backlog`. Factory starts a worker run for `queued` tasks, so
+ * recording work must not enqueue execution by accident.
+ */
+export async function handleCreateFactoryTask(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const title = typeof args.title === "string" ? args.title.trim() : "";
+  const acceptance = typeof args.acceptance === "string" ? args.acceptance.trim() : "";
+
+  if (!title) {
+    return textResponse("Provide 'title' for the task (3-140 characters).");
+  }
+  if (!acceptance) {
+    return textResponse(
+      [
+        "Provide 'acceptance': what must be true for this task to count as done.",
+        "Factory requires it, and it is what the next person checks.",
+      ].join("\n"),
+    );
+  }
+  if (!args.projectId) {
+    return textResponse(
+      "Provide 'projectId'. Run 'list_factory_projects' first - Factory needs a real project UUID.",
+    );
+  }
+
+  try {
+    const created = await createTask(config, {
+      projectId: args.projectId,
+      title,
+      description: args.description,
+      acceptance,
+      priority: args.priority,
+      status: args.status,
+    });
+
+    return textResponse(
+      [
+        `Created task ${created.id ? `[${String(created.id).slice(0, 8)}] ` : ""}${title}`,
+        `Status: ${created.status}${created.status === "backlog" ? " (no worker run started)" : ""}`,
+        created.runId ? `Worker run queued: ${created.runId}` : "",
+        "",
+        created.status === "backlog"
+          ? "Recorded in the backlog. Use claim_factory_task when someone starts working on it."
+          : "Move it out of the queue if execution was not intended.",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    return textResponse(`Could not create the task: ${error.message}`);
+  }
+}

package/tools/handler-modules/index.js

@@ -4,6 +4,7 @@ import { handleSkipRelease, handlePerformRelease } from "./release-handlers.js";
 import { handleCommitAndPush, handleCompleteTask, handleForceCompleteTask, handleDropTask } from "./commit-handlers.js";
 import { handleProjectSummary, handleProjectSummaryData, handleProjectSummaryDb, handleViewHistory } from "./summary-handlers.js";
 import { handleGetWorkflowStatus, handleReadyCheck, handleContinueWorkflow, handleRerunWorkflow } from "./status-handlers.js";
+import { handleListFactoryTasks, handleClaimFactoryTask, handleSyncTaskStatus, handleListFactoryProjects, handleCreateFactoryTask } from "./factory-handlers.js";
 
 function summarizeResponse(label, response) {
   const text = response?.content?.[0]?.text || "";
@@ -216,6 +217,16 @@ export async function handleToolCall({
         return handleRerunWorkflow(workflowState);
       case "run_full_workflow":
         return handleRunFullWorkflow(args, { workflowState, exec, git, utils });
+      case "list_factory_tasks":
+        return handleListFactoryTasks(args);
+      case "list_factory_projects":
+        return handleListFactoryProjects(args);
+      case "create_factory_task":
+        return handleCreateFactoryTask(args);
+      case "claim_factory_task":
+        return handleClaimFactoryTask(args, { workflowState });
+      case "sync_task_status":
+        return handleSyncTaskStatus(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/tools/handler-modules/status-handlers.js

@@ -1,10 +1,30 @@
 import { textResponse, formatChecklist, isReleaseSatisfied, getContinueGuidance, resetToCommitIfWorkingChanges } from "./shared.js";
 import { handleCommitAndPush } from "./commit-handlers.js";
 
-export function handleGetWorkflowStatus(workflowState) {
+export async function handleGetWorkflowStatus(workflowState) {
   const status = workflowState.state;
   const nextStep = status ? status.currentPhase : "idle";
 
+  // Deteksi berkas state yang terakhir ditulis proses MCP lain. Tanpa
+  // peringatan ini, agen bisa meng-commit atas nama task orang lain.
+  let sharedWarning = "";
+  try {
+    const disk = await workflowState.readDiskState();
+    if (workflowState.isForeignWrite(disk)) {
+      const owner = disk.owner || {};
+      sharedWarning =
+        `\n\n⚠️ PERINGATAN: berkas state ini terakhir ditulis proses MCP LAIN ` +
+        `(${owner.token || "tanpa-token"}, pid ${owner.pid ?? "?"}).\n` +
+        `   State workflow dipakai bersama antar sesi di mesin ini.\n` +
+        `   Periksa apakah "Task:" di atas benar-benar milik Anda SEBELUM commit_and_push.`;
+      if (disk.currentPhase && disk.currentPhase !== "idle" && disk.taskDescription) {
+        sharedWarning += `\n   Proses itu sedang mengerjakan: "${disk.taskDescription}"`;
+      }
+    }
+  } catch {
+    // Status tetap ditampilkan walau pemeriksaan berkas gagal.
+  }
+
   return textResponse(
     `📊 Current Workflow Status:
 
@@ -19,7 +39,7 @@ Ready check: ${status.readyCheckCompleted ? "✅" : "❌"}
 Commit & push: ${status.commitAndPushCompleted ? "✅" : "❌"}
 Released: ${status.released ? "✅" : "❌"}
 
-Next step: ${nextStep}`
+Next step: ${nextStep}${sharedWarning}`
   );
 }
 

package/tools/handler-modules/workflow-handlers.js

@@ -1,7 +1,12 @@
 import { textResponse, isReleaseSatisfied, isErrorResponse, ensurePrdExists } from "./shared.js";
 
 export async function handleStartTask(args, workflowState) {
-  workflowState.reset();
+  // Selamatkan dulu pekerjaan yang mungkin tertimpa. Ini menangani dua kasus:
+  //   1. Proses MCP LAIN menulis berkas state setelah kita memuatnya.
+  //   2. Task kita sendiri yang belum selesai lalu diganti task baru.
+  const preservedBeforeSave = await workflowState.reconcileWithDisk();
+  const { archivedTask } = workflowState.reset({ archive: true });
+
   workflowState.state.currentPhase = "coding";
   workflowState.state.taskDescription = args.description;
   workflowState.state.taskType = args.type;
@@ -10,10 +15,34 @@ export async function handleStartTask(args, workflowState) {
   workflowState.state.commitAndPushCompleted = false;
   workflowState.state.lastCommitMessage = "";
   workflowState.state.lastPushBranch = "";
-  await workflowState.save();
+  const reconciled = await workflowState.save();
+
+  const warnings = [];
+  const preservedForeign = reconciled?.preservedTask || preservedBeforeSave?.preservedTask;
+  if (preservedForeign) {
+    warnings.push(
+      `⚠️ Ada task yang SEDANG BERJALAN dari proses agen lain dan hampir tertimpa:\n` +
+        `   "${preservedForeign}"\n` +
+        `   Task itu sudah disimpan ke history sebagai 'interrupted', bukan dihapus.\n` +
+        `   State workflow di mesin ini dipakai bersama antar sesi - periksa sebelum commit.`
+    );
+  }
+  if (archivedTask) {
+    warnings.push(
+      `ℹ️ Task sebelumnya belum selesai dan diganti: "${archivedTask}".\n` +
+        `   Disimpan ke history sebagai 'interrupted'.`
+    );
+  }
+  if (reconciled?.mergedHistory > 0) {
+    warnings.push(
+      `ℹ️ ${reconciled.mergedHistory} entri history dari proses lain digabungkan, tidak ditimpa.`
+    );
+  }
+
+  const warningBlock = warnings.length > 0 ? `\n\n${warnings.join("\n\n")}` : "";
 
   return textResponse(
-    `✅ Task Started: ${args.description}\n\n🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Create tests\n5. ⏳ Run tests (must pass!)\n6. ⏳ Create documentation\n7. ⏳ Run 'check_ready_to_commit'\n8. ⏳ Run 'commit_and_push' (commits and pushes)\n9. ⏳ Run 'perform_release' (handles versioning and tags) or 'skip_release' (when no release is needed)\n10. ⏳ Complete task\n\nReminder: Focus on writing clean, maintainable code!`
+    `✅ Task Started: ${args.description}${warningBlock}\n\n🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Create tests\n5. ⏳ Run tests (must pass!)\n6. ⏳ Create documentation\n7. ⏳ Run 'check_ready_to_commit'\n8. ⏳ Run 'commit_and_push' (commits and pushes)\n9. ⏳ Run 'perform_release' (handles versioning and tags) or 'skip_release' (when no release is needed)\n10. ⏳ Complete task\n\nReminder: Focus on writing clean, maintainable code!`
   );
 }
 

package/vite.config.js

@@ -18,6 +18,12 @@ export default defineConfig({
       },
       external: [
         '@modelcontextprotocol/sdk',
+        // dotenv ships CommonJS only (dist/index.cjs). Bundling it into an ES
+        // module leaks its `require.main === module` guard, which throws
+        // "require is not defined in ES module scope" at startup. Keeping it
+        // external lets Node load it as CJS, which is how it is designed to run.
+        'dotenv',
+        'dotenv/config',
         // Node.js built-in modules
         'node:fs',
         'node:path',

package/workflow-state.js

@@ -14,6 +14,22 @@ const USER_ID_FILENAME = "user-id";
 let cachedUserId = null;
 let cachedUserStateDir = null;
 
+/**
+ * Identitas proses MCP ini.
+ *
+ * MENGAPA ADA
+ * -----------
+ * Berkas state disimpan per USER (`user-id`), bukan per sesi agen. Dua sesi
+ * opencode di mesin yang sama berbagi satu `workflow-state.json`. Akibatnya
+ * sesi B menimpa pekerjaan sesi A tanpa jejak: task A tidak pernah masuk
+ * `history` karena history hanya ditulis saat task DITUTUP.
+ *
+ * Token ini dicap ke setiap penulisan supaya kita bisa mengetahui bahwa isi
+ * berkas di disk terakhir ditulis oleh proses LAIN, lalu menyelamatkan task
+ * yang sedang berjalan itu sebelum kita menimpanya.
+ */
+const PROCESS_TOKEN = `proc-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
+
 function generateUserId() {
   const timestamp = Date.now().toString(16);
   const randomSuffix = Math.random().toString(16).slice(2, 10);
@@ -535,10 +551,119 @@ export class WorkflowState {
   }
 
   async save() {
+    const reconciled = await this.reconcileWithDisk();
+    this.state.owner = {
+      token: PROCESS_TOKEN,
+      pid: process.pid,
+      updatedAt: new Date().toISOString(),
+    };
     await fs.writeFile(this.stateFile, JSON.stringify(this.state, null, 2));
     await ensureCompatibilityLinks(this.stateFile);
     await this.updateProjectSummary();
     await this.syncToDatabase();
+    this.lastReconcile = reconciled;
+    return reconciled;
+  }
+
+  /**
+   * Baca isi berkas state APA ADANYA dari disk (bukan dari memori).
+   * Mengembalikan null kalau belum ada / rusak.
+   */
+  async readDiskState() {
+    try {
+      const data = await fs.readFile(this.stateFile, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+
+  /** True kalau berkas di disk terakhir ditulis proses MCP lain. */
+  isForeignWrite(diskState) {
+    const token = diskState?.owner?.token;
+    return typeof token === "string" && token.length > 0 && token !== PROCESS_TOKEN;
+  }
+
+  historyKey(entry) {
+    return `${entry?.timestamp || ""}|${entry?.taskDescription || ""}`;
+  }
+
+  mergeDiskHistory(diskState) {
+    if (!diskState || !Array.isArray(diskState.history)) {
+      return 0;
+    }
+    if (!Array.isArray(this.state.history)) {
+      this.state.history = [];
+    }
+    const seen = new Set(this.state.history.map((entry) => this.historyKey(entry)));
+    let added = 0;
+    for (const entry of diskState.history) {
+      const key = this.historyKey(entry);
+      if (!seen.has(key)) {
+        this.state.history.push(entry);
+        seen.add(key);
+        added += 1;
+      }
+    }
+    return added;
+  }
+
+  /**
+   * Rekonsiliasi sebelum menulis: jangan buang pekerjaan proses lain.
+   *
+   * 1. Gabungkan `history` dari disk supaya catatan task lain tidak hilang.
+   * 2. Kalau disk memuat task yang SEDANG BERJALAN milik proses lain, arsipkan
+   *    ke `history` sebagai `interrupted` sebelum kita menimpanya.
+   *
+   * Tanpa langkah 2, task itu lenyap tanpa jejak - itulah bug yang menyebabkan
+   * pekerjaan resize docker-alma tidak pernah muncul di view_history.
+   */
+  async reconcileWithDisk() {
+    const result = { mergedHistory: 0, preservedTask: null, foreignToken: null };
+    const disk = await this.readDiskState();
+    if (!disk) {
+      return result;
+    }
+
+    result.mergedHistory = this.mergeDiskHistory(disk);
+
+    if (!this.isForeignWrite(disk)) {
+      return result;
+    }
+
+    result.foreignToken = disk.owner.token;
+
+    const hasRunningTask =
+      typeof disk.taskDescription === "string" &&
+      disk.taskDescription.trim() !== "" &&
+      disk.currentPhase &&
+      disk.currentPhase !== "idle";
+
+    if (!hasRunningTask) {
+      return result;
+    }
+
+    const alreadyArchived = this.state.history.some(
+      (entry) => entry.interrupted && entry.taskDescription === disk.taskDescription
+    );
+    if (alreadyArchived) {
+      return result;
+    }
+
+    this.state.history.push({
+      taskDescription: disk.taskDescription,
+      taskType: disk.taskType || "other",
+      commitMessage: disk.lastCommitMessage || "",
+      interrupted: true,
+      dropped: true,
+      dropReason:
+        "Ditimpa proses agen lain: state workflow dipakai bersama antar sesi di mesin ini",
+      interruptedAtPhase: disk.currentPhase,
+      interruptedBy: disk.owner.token,
+      timestamp: new Date().toISOString(),
+    });
+    result.preservedTask = disk.taskDescription;
+    return result;
   }
 
   async updateProjectSummary() {
@@ -625,7 +750,43 @@ export class WorkflowState {
     };
   }
 
-  reset() {
+  /**
+   * Reset ke keadaan idle.
+   *
+   * `archive` sengaja OPT-IN (default false). Pemanggil yang sudah menulis
+   * `addToHistory` sendiri - complete_task, force_complete_task, drop_task -
+   * akan menghasilkan entri ganda kalau reset ikut mengarsipkan.
+   *
+   * `start_task` memakai `{ archive: true }` supaya task yang sedang berjalan
+   * tidak lenyap saat diganti task baru.
+   */
+  reset(options = {}) {
+    const archive = options.archive === true;
+    const previous = this.state || {};
+    const history = Array.isArray(previous.history) ? previous.history.slice() : [];
+
+    const hasRunningTask =
+      typeof previous.taskDescription === "string" &&
+      previous.taskDescription.trim() !== "" &&
+      previous.currentPhase &&
+      previous.currentPhase !== "idle";
+
+    let archivedTask = null;
+    if (archive && hasRunningTask) {
+      archivedTask = previous.taskDescription;
+      history.push({
+        taskDescription: previous.taskDescription,
+        taskType: previous.taskType || "other",
+        commitMessage: previous.lastCommitMessage || "",
+        interrupted: true,
+        dropped: true,
+        dropReason:
+          options.reason || "Diganti start_task berikutnya sebelum task selesai",
+        interruptedAtPhase: previous.currentPhase,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
     this.state = {
       currentPhase: "idle",
       taskDescription: "",
@@ -647,8 +808,11 @@ export class WorkflowState {
       lastPushBranch: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
-      history: this.state.history,
+      history,
+      taskType: "",
     };
+
+    return { archivedTask };
   }
 
   addToHistory(entry) {

package/scripts/test-auth-flow.js

@@ -1,75 +0,0 @@
-import fetch from 'node-fetch';
-
-const API_BASE_URL = 'https://hollywood-andrew-cycle-genre.trycloudflare.com';
-const USERNAME = 'programinglive';
-const PASSWORD = 'mcpdevserver';
-
-async function testAuthFlow() {
-    console.log('🚀 Starting Auth Flow Test...');
-    console.log(`Target: ${API_BASE_URL}\n`);
-
-    try {
-        // 1. Login
-        console.log('1️⃣  Attempting Login...');
-        const loginRes = await fetch(`${API_BASE_URL}/api/auth/login`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ username: USERNAME, password: PASSWORD }),
-        });
-
-        console.log(`   Status: ${loginRes.status}`);
-        if (!loginRes.ok) {
-            throw new Error(`Login failed: ${loginRes.statusText}`);
-        }
-
-        const loginData = await loginRes.json();
-        const token = loginData.token;
-
-        if (token) {
-            console.log('   ✅ Login Successful! JWT Token received.');
-            console.log(`   Token: ${token.substring(0, 20)}...`);
-        } else {
-            console.log('   ⚠️  Login successful but NO TOKEN returned (Legacy Session mode?)');
-        }
-
-        // 2. Access Protected Route (GET /me)
-        console.log('\n2️⃣  Verifying Session/Token (GET /api/auth/me)...');
-        const headers = {};
-        if (token) {
-            headers['Authorization'] = `Bearer ${token}`;
-            console.log('   Using Authorization: Bearer header');
-        } else {
-            console.log('   Using Cookies (if any)');
-        }
-
-        const meRes = await fetch(`${API_BASE_URL}/api/auth/me`, {
-            headers,
-        });
-
-        console.log(`   Status: ${meRes.status}`);
-        if (meRes.ok) {
-            const meData = await meRes.json();
-            console.log(`   ✅ Authorized! User: ${meData.username} (${meData.email})`);
-        } else {
-            console.error('   ❌ Authorization Failed!');
-            console.error(await meRes.text());
-        }
-
-        // 3. Access History (GET /api/history)
-        console.log('\n3️⃣  Fetching History...');
-        const historyRes = await fetch(`${API_BASE_URL}/api/history`, { headers });
-        console.log(`   Status: ${historyRes.status}`);
-
-        if (historyRes.ok) {
-            const historyData = await historyRes.json();
-            console.log(`   ✅ History fetched! Count: ${historyData.history ? historyData.history.length : 0}`);
-        } else {
-            console.log('   ❌ History fetch failed.');
-        }
-
-    } catch (error) {
-        console.error('\n❌ Test Failed:', error.message);
-    }
-}
-
-testAuthFlow();