kenzoboard 0.1.2 → 0.1.4

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";
@@ -4114,15 +4114,22 @@ async function serveCommand(args, flags, options = {}) {
     app.get("/", (c) => c.text("Web UI not found. API available at /api/*"));
   }
   const url = `http://localhost:${port}`;
-  console.log(`Starting Kenzo on ${url}`);
-  console.log(`Data file: ${dataFile}`);
-  if (webDistPath) {
-    console.log(`Web UI: ${webDistPath}`);
+  if (options.compact) {
+    console.log("");
+    console.log(`Kenzo is running at ${url}`);
   } else {
-    console.log("Web UI: not found (API only mode)");
+    console.log(`Starting Kenzo on ${url}`);
+    console.log(`Data file: ${dataFile}`);
+    if (webDistPath) {
+      console.log(`Web UI: ${webDistPath}`);
+    } else {
+      console.log("Web UI: not found (API only mode)");
+    }
   }
   if (options.open || flags.open === true) {
-    console.log(`Opening ${url}`);
+    if (!options.compact) {
+      console.log(`Opening ${url}`);
+    }
     openBrowser(url);
   }
   console.log("");
@@ -4539,20 +4546,24 @@ function ensureFluxIgnored() {
 ` : "";
     appendFileSync(gitignorePath, `${newline}${gitignoreEntry}
 `);
-    console.log(`Added .flux/ to ${gitRoot ? gitignorePath : ".gitignore"}`);
+    return true;
   }
+  return false;
 }
 async function ensureKenzoWorkspace() {
   const fluxDir = process.env.FLUX_DIR || resolve4(process.cwd(), ".flux");
   const configPath = resolve4(fluxDir, "config.json");
   const jsonPath = resolve4(fluxDir, "data.json");
   const sqlitePath = resolve4(fluxDir, "data.sqlite");
+  let createdWorkspace = false;
+  let createdProject = false;
+  let gitignoreUpdated = false;
   if (!existsSync7(fluxDir)) {
     mkdirSync3(fluxDir, { recursive: true });
     writeConfig(fluxDir, {});
     writeFileSync5(jsonPath, JSON.stringify({ projects: [], epics: [], tasks: [] }, null, 2));
-    ensureFluxIgnored();
-    console.log(`Created local Kenzo workspace at ${fluxDir}`);
+    gitignoreUpdated = ensureFluxIgnored();
+    createdWorkspace = true;
   } else if (!existsSync7(configPath)) {
     writeConfig(fluxDir, {});
   }
@@ -4572,7 +4583,7 @@ async function ensureKenzoWorkspace() {
     const nextConfig = readConfigRaw(fluxDir);
     nextConfig.project = project.id;
     writeConfig(fluxDir, nextConfig);
-    console.log(`Created first project: ${project.name} (${project.id})`);
+    createdProject = true;
   } else if (!projectId || !projects.some((project) => project.id === projectId)) {
     const project = projects[0];
     projectId = project.id;
@@ -4580,29 +4591,68 @@ async function ensureKenzoWorkspace() {
     const nextConfig = readConfigRaw(fluxDir);
     nextConfig.project = project.id;
     writeConfig(fluxDir, nextConfig);
-    console.log(`Using project: ${project.name} (${project.id})`);
   }
-  return { projectId, projectName };
+  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";
+}
+function quoteShell(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+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) {
+  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}`);
+  if (workspace.createdWorkspace || workspace.createdProject || workspace.gitignoreUpdated) {
+    const details = [
+      workspace.createdWorkspace ? "local workspace" : undefined,
+      workspace.createdProject ? "first project" : undefined,
+      workspace.gitignoreUpdated ? ".flux/ in .gitignore" : undefined
+    ].filter(Boolean).join(", ");
+    console.log(`${c2.dim}Set up ${details}.${c2.reset}`);
+  }
+  console.log("");
+  console.log(`${c2.bold}Connect Codex:${c2.reset}`);
+  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}npx kenzoboard ready${c2.reset}`);
+  console.log(`More setup:   ${c2.cyan}npx kenzoboard mcp${c2.reset}`);
 }
-function printMcpSetup(command = publicCommandName()) {
-  const npxMcpCommand = "npx -y --package kenzoboard kenzoboard-mcp";
+function printMcpSetup(command = publicCommandName(), fluxDir = findFluxDir()) {
   const installedMcpCommand = "kenzoboard-mcp";
   const dockerCommand = 'docker run -i --rm -v "$(pwd)/.flux:/app/packages/data" -e FLUX_DATA=/app/packages/data/flux.sqlite flux-mcp bun packages/mcp/dist/index.js';
-  const localMcpPath = resolve4(process.cwd(), "packages/mcp/dist/index.js");
-  console.log(`${c2.bold}Agent setup${c2.reset} ${c2.dim}(MCP resources remain flux:// for compatibility)${c2.reset}
+  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}`);
-  if (existsSync7(localMcpPath)) {
-    console.log(`  codex mcp add flux -- bun ${localMcpPath}`);
-  } else {
-    console.log(`  codex mcp add flux -- ${npxMcpCommand}`);
-  }
+  console.log(`  ${codexMcpCommand(fluxDir)}`);
   console.log(`${c2.bold}Claude Code:${c2.reset}`);
-  if (existsSync7(localMcpPath)) {
-    console.log(`  claude mcp add flux -- bun ${localMcpPath}`);
-  } else {
-    console.log(`  claude mcp add flux -- ${npxMcpCommand}`);
-  }
+  console.log(`  ${claudeMcpCommand(fluxDir)}`);
   console.log("");
   console.log(`${c2.bold}Global install:${c2.reset}`);
   console.log(`  ${installedMcpCommand}`);
@@ -4610,18 +4660,93 @@ function printMcpSetup(command = publicCommandName()) {
   console.log(`${c2.bold}Advanced Docker:${c2.reset}`);
   console.log(`  ${dockerCommand}`);
   console.log("");
-  console.log(`Run ${c2.cyan}${command} ready${c2.reset} to see agent-ready work.`);
+  console.log(`${c2.bold}Agent workflow:${c2.reset}`);
+  console.log(`  1. Run ${c2.cyan}${command} ready${c2.reset} or ask the MCP server for ready tasks.`);
+  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.");
 }
-async function launchKenzoApp() {
-  const command = publicCommandName();
-  const { projectId, projectName } = await ensureKenzoWorkspace();
-  if (projectId && projectName) {
-    console.log(`Opening project: ${projectName} (${projectId})`);
+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"]
+  });
+}
+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.");
+    }
+    console.log(`${c2.green}${c2.bold}Codex is connected to Kenzo.${c2.reset}`);
+    console.log(`Server: ${serverName}`);
+    console.log(`Workspace: ${workspace.fluxDir}`);
+    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);
   }
-  console.log("");
-  console.log(`${c2.bold}Next step after Kenzo opens:${c2.reset}`);
-  printMcpSetup(command);
-  await serveCommand([], { port: String(defaultServePort()) }, { defaultPort: defaultServePort(), open: true });
+}
+async function launchKenzoApp() {
+  const workspace = await ensureKenzoWorkspace();
+  printLaunchSummary(workspace);
+  await serveCommand([], { port: String(defaultServePort()) }, { defaultPort: defaultServePort(), open: true, compact: true });
 }
 var FLUX_INSTRUCTIONS = `<!-- FLUX:START -->
 ## Flux Task Management
@@ -5183,6 +5308,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;
@@ -5294,6 +5427,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.2",
+  "version": "0.1.4",
   "description": "Kenzo board for human-led AI work, powered by the Flux engine",
   "type": "module",
   "bin": {