kenzoboard 0.1.3 → 0.1.5

package/dist/index.js

@@ -85,7 +85,7 @@ var init_blob_storage = () => {};
 
 // src/index.ts
 import { resolve as resolve4, dirname as dirname4, basename as basename2 } from "path";
-import { execSync } from "child_process";
+import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, appendFileSync, cpSync, realpathSync } from "fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { createInterface } from "readline";
@@ -4595,6 +4595,9 @@ async function ensureKenzoWorkspace() {
   return { fluxDir, projectId, projectName, createdWorkspace, createdProject, gitignoreUpdated };
 }
 function codexCliCommand() {
+  if (process.env.CODEX_CLI_PATH && existsSync7(process.env.CODEX_CLI_PATH)) {
+    return process.env.CODEX_CLI_PATH;
+  }
   const macAppCli = "/Applications/Codex.app/Contents/Resources/codex";
   return process.platform === "darwin" && existsSync7(macAppCli) ? macAppCli : "codex";
 }
@@ -4605,13 +4608,17 @@ function mcpPackageCommand() {
   const localMcpPath = resolve4(process.cwd(), "packages/mcp/dist/index.js");
   return existsSync7(localMcpPath) ? `bun ${quoteShell(localMcpPath)}` : "npx -y --package kenzoboard kenzoboard-mcp";
 }
+function mcpPackageArgs() {
+  const localMcpPath = resolve4(process.cwd(), "packages/mcp/dist/index.js");
+  return existsSync7(localMcpPath) ? ["bun", localMcpPath] : ["npx", "-y", "--package", "kenzoboard", "kenzoboard-mcp"];
+}
 function codexMcpCommand(fluxDir) {
   return `${codexCliCommand()} mcp add flux --env FLUX_DIR=${quoteShell(fluxDir)} -- ${mcpPackageCommand()}`;
 }
 function claudeMcpCommand(fluxDir) {
   return `claude mcp add flux --env FLUX_DIR=${quoteShell(fluxDir)} -- ${mcpPackageCommand()}`;
 }
-function printLaunchSummary(workspace, command = publicCommandName()) {
+function printLaunchSummary(workspace) {
   const projectLabel = workspace.projectName && workspace.projectId ? `${workspace.projectName} (${workspace.projectId})` : "No project selected";
   console.log(`${c2.green}${c2.bold}Kenzo is ready.${c2.reset}`);
   console.log(`Project: ${projectLabel}`);
@@ -4625,13 +4632,13 @@ function printLaunchSummary(workspace, command = publicCommandName()) {
   }
   console.log("");
   console.log(`${c2.bold}Connect Codex:${c2.reset}`);
-  console.log(`  ${codexMcpCommand(workspace.fluxDir)}`);
+  console.log("  npx kenzoboard connect codex");
   console.log("");
   console.log(`${c2.bold}Then ask Codex:${c2.reset}`);
   console.log("  Pick the next ready Kenzo task, implement it, and mark it done.");
   console.log("");
-  console.log(`CLI fallback: ${c2.cyan}${command} ready${c2.reset}`);
-  console.log(`More setup:   ${c2.cyan}${command} mcp${c2.reset}`);
+  console.log(`CLI fallback: ${c2.cyan}npx kenzoboard ready${c2.reset}`);
+  console.log(`More setup:   ${c2.cyan}npx kenzoboard mcp${c2.reset}`);
 }
 function printMcpSetup(command = publicCommandName(), fluxDir = findFluxDir()) {
   const installedMcpCommand = "kenzoboard-mcp";
@@ -4639,6 +4646,9 @@ function printMcpSetup(command = publicCommandName(), fluxDir = findFluxDir()) {
   console.log(`${c2.bold}Agent setup${c2.reset} ${c2.dim}(MCP resources remain flux:// for compatibility)${c2.reset}`);
   console.log(`${c2.dim}Using Kenzo workspace: ${fluxDir}${c2.reset}
 `);
+  console.log(`${c2.bold}Codex one-step setup:${c2.reset}`);
+  console.log("  npx kenzoboard connect codex");
+  console.log("");
   console.log(`${c2.bold}Codex:${c2.reset}`);
   console.log(`  ${codexMcpCommand(fluxDir)}`);
   console.log(`${c2.bold}Claude Code:${c2.reset}`);
@@ -4655,10 +4665,123 @@ function printMcpSetup(command = publicCommandName(), fluxDir = findFluxDir()) {
   console.log("  2. Start one task, implement it, add notes as needed, then mark it done.");
   console.log("  3. If MCP is not connected yet, Codex can still use the CLI commands from AGENTS.md.");
 }
+function codexCliLooksValid(command) {
+  try {
+    const output2 = execFileSync(command, ["mcp", "--help"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return output2.includes("Manage external MCP servers for Codex");
+  } catch {
+    return false;
+  }
+}
+function resolveCodexCli() {
+  const candidates = [
+    process.env.CODEX_CLI_PATH,
+    process.platform === "darwin" ? "/Applications/Codex.app/Contents/Resources/codex" : undefined,
+    "codex"
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    if (candidate.includes("/") && !existsSync7(candidate))
+      continue;
+    if (codexCliLooksValid(candidate))
+      return candidate;
+  }
+  return null;
+}
+function runCodex(cli, args) {
+  return execFileSync(cli, args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function verifyMcpServer(args, fluxDir) {
+  const input = [
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "kenzoboard-connect", version: "0.0.0" }
+      }
+    }),
+    JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }),
+    JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })
+  ].join(`
+`) + `
+`;
+  const output2 = execFileSync(args[0], args.slice(1), {
+    input,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 30000,
+    env: {
+      ...process.env,
+      FLUX_DIR: fluxDir
+    }
+  });
+  const responses = output2.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  const tools = responses.find((response) => response.id === 2)?.result?.tools;
+  if (!tools?.some((tool) => tool.name === "list_ready_tasks")) {
+    throw new Error("MCP server started, but did not expose the expected Kenzo task tools.");
+  }
+}
+async function connectCodexCommand(flags) {
+  const workspace = await ensureKenzoWorkspace();
+  const cli = resolveCodexCli();
+  if (!cli) {
+    console.error("OpenAI Codex CLI was not found.");
+    console.error("Install or open Codex Desktop, then run this again.");
+    console.error("");
+    console.error("Manual command:");
+    console.error(`  ${codexMcpCommand(workspace.fluxDir)}`);
+    process.exit(1);
+  }
+  const serverName = typeof flags.name === "string" ? flags.name : "flux";
+  const packageArgs = mcpPackageArgs();
+  const addArgs = [
+    "mcp",
+    "add",
+    serverName,
+    "--env",
+    `FLUX_DIR=${workspace.fluxDir}`,
+    "--",
+    ...packageArgs
+  ];
+  try {
+    runCodex(cli, ["mcp", "get", serverName]);
+    runCodex(cli, ["mcp", "remove", serverName]);
+  } catch {}
+  try {
+    runCodex(cli, addArgs);
+    const result = runCodex(cli, ["mcp", "get", serverName]);
+    if (!result.includes(serverName) || !result.includes(packageArgs[0])) {
+      throw new Error("Codex did not report the expected MCP server after setup.");
+    }
+    verifyMcpServer(packageArgs, workspace.fluxDir);
+    console.log(`${c2.green}${c2.bold}Codex is connected to Kenzo.${c2.reset}`);
+    console.log(`Server: ${serverName}`);
+    console.log(`Workspace: ${workspace.fluxDir}`);
+    console.log("MCP tools: verified");
+    console.log("");
+    console.log(`${c2.bold}Try this in Codex:${c2.reset}`);
+    console.log("  Use Kenzo to pick the next ready task, implement it, and mark it done.");
+  } catch (e) {
+    console.error("Failed to configure Codex MCP.");
+    console.error(e?.message || String(e));
+    console.error("");
+    console.error("Manual command:");
+    console.error(`  ${codexMcpCommand(workspace.fluxDir)}`);
+    process.exit(1);
+  }
+}
 async function launchKenzoApp() {
-  const command = publicCommandName();
   const workspace = await ensureKenzoWorkspace();
-  printLaunchSummary(workspace, command);
+  printLaunchSummary(workspace);
   await serveCommand([], { port: String(defaultServePort()) }, { defaultPort: defaultServePort(), open: true, compact: true });
 }
 var FLUX_INSTRUCTIONS = `<!-- FLUX:START -->
@@ -5221,6 +5344,14 @@ Select a project:`);
     printMcpSetup();
     return;
   }
+  if (parsed.command === "connect") {
+    if (parsed.subcommand === "codex") {
+      await connectCodexCommand(parsed.flags);
+      return;
+    }
+    console.error(`Usage: ${publicCommandName()} connect codex [--name flux]`);
+    process.exit(1);
+  }
   if (parsed.command === "dev") {
     await launchKenzoApp();
     return;
@@ -5332,6 +5463,7 @@ ${c2.bold}Start:${c2.reset}
   ${c2.cyan}${command} init${c2.reset} ${c2.green}[--server URL] [--api-key KEY] [--sqlite] [--git] [--force]${c2.reset}
   ${c2.cyan}${command} dev${c2.reset} ${c2.green}[--open]${c2.reset}                 Start the local Kenzo app on port ${defaultServePort()}
   ${c2.cyan}${command} serve${c2.reset} ${c2.green}[-p port] [--data file] [--open]${c2.reset}
+  ${c2.cyan}${command} connect codex${c2.reset} ${c2.green}[--name flux]${c2.reset}  Configure Codex MCP for this workspace
   ${c2.cyan}${command} mcp${c2.reset}                         Show Codex/Claude MCP setup commands
 
 ${c2.bold}Ready Work:${c2.reset}

package/dist/mcp.js

@@ -15119,6 +15119,11 @@ var server = new Server({
     tools: {}
   }
 });
+function jsonContent(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+  };
+}
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   const projects = await getProjects2();
   const resources = [
@@ -15621,11 +15626,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     case "create_project": {
       const project = await createProject2(args2?.name, args2?.description);
-      return {
-        content: [
-          { type: "text", text: `Created project "${project.name}" with ID: ${project.id}` }
-        ]
-      };
+      return jsonContent({ action: "created_project", project });
     }
     case "update_project": {
       const updates = {};
@@ -15637,15 +15638,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!project) {
         return { content: [{ type: "text", text: "Project not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Updated project: ${JSON.stringify(project, null, 2)}` }]
-      };
+      return jsonContent({ action: "updated_project", project });
     }
     case "delete_project": {
-      await deleteProject2(args2?.project_id);
-      return {
-        content: [{ type: "text", text: `Deleted project ${args2?.project_id}` }]
-      };
+      const deleted = await deleteProject2(args2?.project_id);
+      return jsonContent({ action: "deleted_project", project_id: args2?.project_id, deleted });
     }
     case "list_epics": {
       const epics = await getEpics2(args2?.project_id);
@@ -15655,9 +15652,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     case "create_epic": {
       const epic = await createEpic2(args2?.project_id, args2?.title, args2?.notes, args2?.auto);
-      return {
-        content: [{ type: "text", text: `Created epic "${epic.title}" with ID: ${epic.id}` }]
-      };
+      return jsonContent({ action: "created_epic", epic });
     }
     case "update_epic": {
       const updates = {};
@@ -15675,18 +15670,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!epic) {
         return { content: [{ type: "text", text: "Epic not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Updated epic: ${JSON.stringify(epic, null, 2)}` }]
-      };
+      return jsonContent({ action: "updated_epic", epic });
     }
     case "delete_epic": {
       const success = await deleteEpic2(args2?.epic_id);
       if (!success) {
         return { content: [{ type: "text", text: "Epic not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Deleted epic ${args2?.epic_id}` }]
-      };
+      return jsonContent({ action: "deleted_epic", epic_id: args2?.epic_id, deleted: true });
     }
     case "list_tasks": {
       const taskList = await getTasks2(args2?.project_id);
@@ -15715,9 +15706,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         acceptance_criteria: args2?.acceptance_criteria,
         guardrails: args2?.guardrails
       });
-      return {
-        content: [{ type: "text", text: `Created task "${task.title}" with ID: ${task.id}` }]
-      };
+      return jsonContent({ action: "created_task", task });
     }
     case "update_task": {
       if (args2?.status === "in_progress") {
@@ -15759,23 +15748,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!task) {
         return { content: [{ type: "text", text: "Task not found" }], isError: true };
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Updated task: ${JSON.stringify({ ...task, blocked: await isTaskBlocked2(task.id) }, null, 2)}`
-          }
-        ]
-      };
+      return jsonContent({ action: "updated_task", task: { ...task, blocked: await isTaskBlocked2(task.id) } });
     }
     case "delete_task": {
       const success = await deleteTask2(args2?.task_id);
       if (!success) {
         return { content: [{ type: "text", text: "Task not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Deleted task ${args2?.task_id}` }]
-      };
+      return jsonContent({ action: "deleted_task", task_id: args2?.task_id, deleted: true });
     }
     case "move_task_status": {
       if (args2?.status === "in_progress") {
@@ -15802,11 +15782,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!task) {
         return { content: [{ type: "text", text: "Task not found" }], isError: true };
       }
-      return {
-        content: [
-          { type: "text", text: `Moved task "${task.title}" to ${args2?.status}` }
-        ]
-      };
+      return jsonContent({ action: "moved_task_status", task });
     }
     case "add_task_comment": {
       const body = args2?.body?.trim();
@@ -15819,18 +15795,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!comment) {
         return { content: [{ type: "text", text: "Task not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Added comment ${comment.id}` }]
-      };
+      return jsonContent({ action: "added_task_comment", comment });
     }
     case "delete_task_comment": {
       const success = await deleteTaskComment2(args2?.task_id, args2?.comment_id);
       if (!success) {
         return { content: [{ type: "text", text: "Comment not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Deleted comment ${args2?.comment_id}` }]
-      };
+      return jsonContent({ action: "deleted_task_comment", task_id: args2?.task_id, comment_id: args2?.comment_id, deleted: true });
     }
     case "list_webhooks": {
       const webhooks = await getWebhooks2();
@@ -15843,11 +15815,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         secret: args2?.secret,
         project_id: args2?.project_id
       });
-      return {
-        content: [
-          { type: "text", text: `Created webhook "${webhook.name}" with ID: ${webhook.id}` }
-        ]
-      };
+      return jsonContent({ action: "created_webhook", webhook });
     }
     case "update_webhook": {
       const updates = {};
@@ -15867,18 +15835,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (!webhook) {
         return { content: [{ type: "text", text: "Webhook not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Updated webhook: ${JSON.stringify(webhook, null, 2)}` }]
-      };
+      return jsonContent({ action: "updated_webhook", webhook });
     }
     case "delete_webhook": {
       const success = await deleteWebhook2(args2?.webhook_id);
       if (!success) {
         return { content: [{ type: "text", text: "Webhook not found" }], isError: true };
       }
-      return {
-        content: [{ type: "text", text: `Deleted webhook ${args2?.webhook_id}` }]
-      };
+      return jsonContent({ action: "deleted_webhook", webhook_id: args2?.webhook_id, deleted: true });
     }
     case "list_webhook_deliveries": {
       const limit = args2?.limit || 20;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenzoboard",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Kenzo board for human-led AI work, powered by the Flux engine",
   "type": "module",
   "bin": {