odoo-forge 0.1.9 → 0.1.11

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "odoo-forge",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "CLI installer and updater for Odoo Forge internal 1.0.",
   "type": "module",
   "dependencies": {
-    "odoo-forge-bundle": "0.1.9"
+    "odoo-forge-bundle": "0.1.11"
   },
   "bin": {
     "odoo-forge": "bin/odoo-forge.js"

package/src/index.js

@@ -1,16 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import readline from "node:readline/promises";
-import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-
-import { installClaudeWiring, readClaudeManagedToken } from "./claude.js";
-import { installCodexWiring, readCodexManagedToken } from "./codex.js";
 import {
   getAgentsSkillsRoot,
-  getClaudeConfigPath,
-  getCodexConfigPath,
   getInstalledSkillsPath,
   getLegacyInstalledSkillsPath,
 } from "./paths.js";
@@ -21,9 +14,7 @@ function printHelp() {
 Usage:
   odoo-forge install
   odoo-forge update
-  odoo-forge doctor
-  odoo-forge login flowus
-  odoo-forge mcp flowus`);
+  odoo-forge doctor`);
 }
 
 async function resolveBundleRoot(bundleRootOverride) {
@@ -42,29 +33,6 @@ async function resolveBundleRoot(bundleRootOverride) {
   }
 }
 
-async function defaultPromptForSecret(message) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  try {
-    return await rl.question(message);
-  } finally {
-    rl.close();
-  }
-}
-
-async function defaultSpawnProcess(command, args, options = {}) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: "inherit",
-      ...options,
-    });
-    child.on("close", (code) => resolve(code ?? 0));
-    child.on("error", reject);
-  });
-}
-
 function installSkills({ bundleRoot, homeDir }) {
   const sourceSkillsDir = path.join(bundleRoot, "skills");
   const targetSkillsDir = getInstalledSkillsPath({ homeDir });
@@ -84,120 +52,43 @@ function installSkills({ bundleRoot, homeDir }) {
   return targetSkillsDir;
 }
 
-async function ensureFlowusToken({ ctx }) {
-  const envToken = ctx.env.ODOO_FORGE_FLOWUS_TOKEN ?? ctx.env.FLOWUS_TOKEN;
-  const currentToken =
-    envToken ??
-    readCodexManagedToken({ homeDir: ctx.homeDir }) ??
-    readClaudeManagedToken({ homeDir: ctx.homeDir });
-
-  if (currentToken) {
-    return currentToken;
+function countInstalledSkills(skillsPath) {
+  if (!fs.existsSync(skillsPath)) {
+    return 0;
   }
 
-  const prompted = await ctx.promptForSecret("FlowUS token is required.\nPaste your FlowUS token: ");
-  const token = prompted.trim();
-  if (!token) {
-    throw new Error("FlowUS token is required.");
-  }
-  return token;
+  return fs
+    .readdirSync(skillsPath, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .length;
 }
 
 function runDoctor(ctx) {
   const skillsPath = getInstalledSkillsPath({ homeDir: ctx.homeDir });
-  const codexConfigPath = getCodexConfigPath({ homeDir: ctx.homeDir });
-  const claudeConfigPath = getClaudeConfigPath({ homeDir: ctx.homeDir });
-  const codexToken = readCodexManagedToken({ homeDir: ctx.homeDir });
-  const claudeToken = readClaudeManagedToken({ homeDir: ctx.homeDir });
 
   ctx.output.log("Odoo Forge doctor");
   ctx.output.log(`Skills root: ${skillsPath}`);
   ctx.output.log(`Skills installed: ${fs.existsSync(skillsPath) ? "yes" : "no"}`);
-  ctx.output.log(`Codex config exists: ${fs.existsSync(codexConfigPath) ? "yes" : "no"}`);
-  ctx.output.log(`Codex FlowUS MCP exists: ${codexToken ? "yes" : "no"}`);
-  ctx.output.log(`Claude config exists: ${fs.existsSync(claudeConfigPath) ? "yes" : "no"}`);
-  ctx.output.log(`Claude FlowUS MCP exists: ${claudeToken ? "yes" : "no"}`);
-  ctx.output.log(`FlowUS token synchronized: ${codexToken && claudeToken && codexToken === claudeToken ? "yes" : "no"}`);
+  ctx.output.log(`Installed skills count: ${countInstalledSkills(skillsPath)}`);
 }
 
 async function runInstallLike(ctx, mode) {
   const bundleRoot = await resolveBundleRoot(ctx.bundleRoot);
-  const token = await ensureFlowusToken({ ctx });
   const skillsPath = installSkills({
     bundleRoot,
     homeDir: ctx.homeDir,
   });
 
-  const codexResult = installCodexWiring({
-    homeDir: ctx.homeDir,
-    token,
-  });
-  const claudeResult = installClaudeWiring({
-    homeDir: ctx.homeDir,
-    token,
-  });
-
   ctx.output.log(`${mode} complete.`);
   ctx.output.log(`Skills root: ${skillsPath}`);
-  ctx.output.log(`Codex config: ${codexResult.configPath}`);
-  ctx.output.log(`Claude config: ${claudeResult.configPath}`);
-}
-
-async function runLogin(ctx, provider) {
-  if (provider !== "flowus") {
-    throw new Error(`Unsupported provider: ${provider}`);
-  }
-
-  const token =
-    ctx.env.ODOO_FORGE_FLOWUS_TOKEN ??
-    ctx.env.FLOWUS_TOKEN ??
-    (await ctx.promptForSecret("Paste your FlowUS token: ")).trim();
-
-  if (!token) {
-    throw new Error("FlowUS token is required.");
-  }
-
-  const codexResult = installCodexWiring({
-    homeDir: ctx.homeDir,
-    token,
-  });
-  const claudeResult = installClaudeWiring({
-    homeDir: ctx.homeDir,
-    token,
-  });
-
-  ctx.output.log(`Saved FlowUS token to ${codexResult.configPath}`);
-  ctx.output.log(`Saved FlowUS token to ${claudeResult.configPath}`);
-}
-
-async function runMcp(ctx, provider) {
-  if (provider !== "flowus") {
-    throw new Error(`Unsupported MCP provider: ${provider}`);
-  }
-
-  const token = ctx.env.FLOWUS_TOKEN ?? ctx.env.ODOO_FORGE_FLOWUS_TOKEN;
-
-  if (!token) {
-    throw new Error("Missing FlowUS token. Set FLOWUS_TOKEN before running `odoo-forge mcp flowus`.");
-  }
-
-  return await ctx.spawnProcess("npx", ["-y", "flowus-mcp-server@latest"], {
-    env: {
-      ...ctx.env,
-      FLOWUS_TOKEN: token,
-    },
-  });
+  ctx.output.log(`Installed skills count: ${countInstalledSkills(skillsPath)}`);
 }
 
 function normalizeContext(overrides = {}) {
   return {
     homeDir: overrides.homeDir ?? os.homedir(),
-    platform: overrides.platform ?? process.platform,
-    env: overrides.env ?? process.env,
     bundleRoot: overrides.bundleRoot,
     output: overrides.output ?? console,
-    promptForSecret: overrides.promptForSecret ?? defaultPromptForSecret,
-    spawnProcess: overrides.spawnProcess ?? defaultSpawnProcess,
   };
 }
 
@@ -215,12 +106,6 @@ export async function main(argv, overrides = {}) {
     case "doctor":
       runDoctor(ctx);
       break;
-    case "login":
-      await runLogin(ctx, argv[1]);
-      break;
-    case "mcp":
-      await runMcp(ctx, argv[1]);
-      break;
     case "help":
     case "--help":
     case "-h":

package/src/paths.js

@@ -1,14 +1,6 @@
 import os from "node:os";
 import path from "node:path";
 
-export function getCodexConfigPath({ homeDir = os.homedir() } = {}) {
-  return path.join(homeDir, ".codex", "config.toml");
-}
-
-export function getClaudeConfigPath({ homeDir = os.homedir() } = {}) {
-  return path.join(homeDir, ".claude.json");
-}
-
 export function getAgentsSkillsRoot({ homeDir = os.homedir() } = {}) {
   return path.join(homeDir, ".agents", "skills");
 }

package/src/claude.js

@@ -1,50 +0,0 @@
-import fs from "node:fs";
-
-import { getClaudeConfigPath } from "./paths.js";
-
-export function readClaudeConfig({ homeDir }) {
-  const configPath = getClaudeConfigPath({ homeDir });
-  if (!fs.existsSync(configPath)) {
-    return {};
-  }
-
-  return JSON.parse(fs.readFileSync(configPath, "utf8"));
-}
-
-export function writeClaudeConfig({ homeDir, config }) {
-  const configPath = getClaudeConfigPath({ homeDir });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  return configPath;
-}
-
-export function buildClaudeFlowusServer({ token }) {
-  return {
-    type: "stdio",
-    command: "npx",
-    args: ["-y", "flowus-mcp-server@latest"],
-    env: {
-      FLOWUS_TOKEN: token,
-    },
-  };
-}
-
-export function installClaudeWiring({ homeDir, token }) {
-  const currentConfig = readClaudeConfig({ homeDir });
-  const nextConfig = {
-    ...currentConfig,
-    mcpServers: {
-      ...(currentConfig.mcpServers ?? {}),
-      flowus: buildClaudeFlowusServer({ token }),
-    },
-  };
-  const configPath = writeClaudeConfig({ homeDir, config: nextConfig });
-
-  return {
-    configPath,
-  };
-}
-
-export function readClaudeManagedToken({ homeDir }) {
-  const config = readClaudeConfig({ homeDir });
-  return config?.mcpServers?.flowus?.env?.FLOWUS_TOKEN ?? null;
-}

package/src/codex.js

@@ -1,158 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-import { getCodexConfigPath } from "./paths.js";
-
-export const CODEX_START_MARKER = "# BEGIN ODOO FORGE FLOWUS";
-export const CODEX_END_MARKER = "# END ODOO FORGE FLOWUS";
-
-export function buildCodexManagedBlock({ token }) {
-  return `${CODEX_START_MARKER}
-[mcp_servers.flowus]
-type = "stdio"
-command = "npx"
-args = ["-y", "flowus-mcp-server@latest"]
-
-[mcp_servers.flowus.env]
-FLOWUS_TOKEN = "${token}"
-${CODEX_END_MARKER}`;
-}
-
-function stripManagedBlock({
-  originalContent,
-  startMarker,
-  endMarker,
-}) {
-  const startIndex = originalContent.indexOf(startMarker);
-  const endIndex = originalContent.indexOf(endMarker);
-
-  if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
-    return originalContent;
-  }
-
-  const blockEnd = endIndex + endMarker.length;
-  return `${originalContent.slice(0, startIndex)}${originalContent.slice(blockEnd)}`;
-}
-
-function isFlowusSectionHeader(headerName) {
-  return headerName === "mcp_servers.flowus" || headerName.startsWith("mcp_servers.flowus.");
-}
-
-function removeFlowusSections(originalContent) {
-  const lines = originalContent.split("\n");
-  const keptLines = [];
-  let skipCurrentSection = false;
-
-  for (const line of lines) {
-    const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
-    if (sectionMatch) {
-      skipCurrentSection = isFlowusSectionHeader(sectionMatch[1]);
-    }
-
-    if (!skipCurrentSection) {
-      keptLines.push(line);
-    }
-  }
-
-  return keptLines.join("\n");
-}
-
-function readSectionContent({ originalContent, sectionName }) {
-  const lines = originalContent.split("\n");
-  const collected = [];
-  let inSection = false;
-
-  for (const line of lines) {
-    const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
-    if (sectionMatch) {
-      if (inSection) {
-        break;
-      }
-      inSection = sectionMatch[1] === sectionName;
-      continue;
-    }
-
-    if (inSection) {
-      collected.push(line);
-    }
-  }
-
-  return inSection ? collected.join("\n") : null;
-}
-
-function extractTokenFromContent(originalContent) {
-  const flowusSection = readSectionContent({
-    originalContent,
-    sectionName: "mcp_servers.flowus",
-  });
-  const envSection = readSectionContent({
-    originalContent,
-    sectionName: "mcp_servers.flowus.env",
-  });
-
-  const candidates = [envSection, flowusSection, originalContent];
-  for (const candidate of candidates) {
-    if (!candidate) {
-      continue;
-    }
-
-    const inlineMatch = candidate.match(/FLOWUS_TOKEN\s*=\s*"([^"]+)"/);
-    if (inlineMatch) {
-      return inlineMatch[1];
-    }
-  }
-
-  return null;
-}
-
-export function upsertManagedBlock({
-  originalContent,
-  startMarker,
-  endMarker,
-  block,
-}) {
-  const withoutManagedBlock = stripManagedBlock({
-    originalContent,
-    startMarker,
-    endMarker,
-  });
-  const withoutFlowusSections = removeFlowusSections(withoutManagedBlock);
-  const trimmed = withoutFlowusSections.trimEnd();
-  return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
-}
-
-export function readCodexManagedToken({ homeDir }) {
-  const configPath = getCodexConfigPath({ homeDir });
-  if (!fs.existsSync(configPath)) {
-    return null;
-  }
-
-  const content = fs.readFileSync(configPath, "utf8");
-  const startIndex = content.indexOf(CODEX_START_MARKER);
-  const endIndex = content.indexOf(CODEX_END_MARKER);
-  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
-    const managedBlock = content.slice(startIndex, endIndex + CODEX_END_MARKER.length);
-    return extractTokenFromContent(managedBlock);
-  }
-
-  return extractTokenFromContent(content);
-}
-
-export function installCodexWiring({ homeDir, token }) {
-  const configPath = getCodexConfigPath({ homeDir });
-  const codexDir = path.dirname(configPath);
-
-  fs.mkdirSync(codexDir, { recursive: true });
-  const currentConfig = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
-  const nextConfig = upsertManagedBlock({
-    originalContent: currentConfig,
-    startMarker: CODEX_START_MARKER,
-    endMarker: CODEX_END_MARKER,
-    block: buildCodexManagedBlock({ token }),
-  });
-  fs.writeFileSync(configPath, nextConfig);
-
-  return {
-    configPath,
-  };
-}