odoo-forge 0.1.0 → 0.1.1

package/package.json

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

package/src/claude.js

@@ -1,92 +1,50 @@
 import fs from "node:fs";
-import path from "node:path";
 
-const MARKETPLACE_NAME = "odoo-forge-marketplace";
-const PLUGIN_NAME = "odoo-forge";
+import { getClaudeConfigPath } from "./paths.js";
 
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
-}
-
-export function renderClaudeMarketplace({
-  bundleRoot,
-  destinationRoot,
-  version,
-}) {
-  const marketplaceDir = path.join(destinationRoot, "claude-marketplace");
-  const pluginDir = path.join(marketplaceDir, "plugins", PLUGIN_NAME);
-  const skillsSource = path.join(bundleRoot, "skills");
+export function readClaudeConfig({ homeDir }) {
+  const configPath = getClaudeConfigPath({ homeDir });
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
 
-  fs.rmSync(marketplaceDir, { force: true, recursive: true });
-  fs.mkdirSync(pluginDir, { recursive: true });
+  return JSON.parse(fs.readFileSync(configPath, "utf8"));
+}
 
-  writeJson(path.join(marketplaceDir, ".claude-plugin", "marketplace.json"), {
-    name: MARKETPLACE_NAME,
-    owner: {
-      name: "Odoo Forge Team",
-    },
-    metadata: {
-      description: "Internal marketplace for Odoo Forge.",
-      version,
-      pluginRoot: "./plugins",
-    },
-    plugins: [
-      {
-        name: PLUGIN_NAME,
-        description: "Internal Odoo Forge skill suite.",
-        source: "./plugins/odoo-forge",
-        category: "development",
-      },
-    ],
-  });
+export function writeClaudeConfig({ homeDir, config }) {
+  const configPath = getClaudeConfigPath({ homeDir });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+}
 
-  writeJson(path.join(pluginDir, ".claude-plugin", "plugin.json"), {
-    name: PLUGIN_NAME,
-    description: "Internal Odoo Forge plugin for Claude Code.",
-    version,
-    author: {
-      name: "Internal Team",
+export function buildClaudeFlowusServer({ token }) {
+  return {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "flowus-mcp-server@latest"],
+    env: {
+      FLOWUS_TOKEN: token,
     },
-  });
+  };
+}
 
-  writeJson(path.join(pluginDir, ".mcp.json"), {
+export function installClaudeWiring({ homeDir, token }) {
+  const currentConfig = readClaudeConfig({ homeDir });
+  const nextConfig = {
+    ...currentConfig,
     mcpServers: {
-      flowus: {
-        type: "stdio",
-        command: "odoo-forge",
-        args: ["mcp", "flowus"],
-      },
+      ...(currentConfig.mcpServers ?? {}),
+      flowus: buildClaudeFlowusServer({ token }),
     },
-  });
-
-  fs.cpSync(skillsSource, path.join(pluginDir, "skills"), { recursive: true });
+  };
+  const configPath = writeClaudeConfig({ homeDir, config: nextConfig });
 
-  return marketplaceDir;
+  return {
+    configPath,
+  };
 }
 
-export function buildClaudeCommandPlan({ marketplaceDir, mode }) {
-  if (mode === "update") {
-    return [
-      {
-        command: "claude",
-        args: ["plugin", "marketplace", "update", MARKETPLACE_NAME],
-      },
-      {
-        command: "claude",
-        args: ["plugin", "update", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`, "--scope", "user"],
-      },
-    ];
-  }
-
-  return [
-    {
-      command: "claude",
-      args: ["plugin", "marketplace", "add", marketplaceDir],
-    },
-    {
-      command: "claude",
-      args: ["plugin", "install", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`, "--scope", "user"],
-    },
-  ];
+export function readClaudeManagedToken({ homeDir }) {
+  const config = readClaudeConfig({ homeDir });
+  return config?.mcpServers?.flowus?.env?.FLOWUS_TOKEN ?? null;
 }

package/src/codex.js

@@ -1,17 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { getCodexConfigPath, getCodexSkillsLinkPath } from "./paths.js";
+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() {
+export function buildCodexManagedBlock({ token }) {
   return `${CODEX_START_MARKER}
 [mcp_servers.flowus]
 type = "stdio"
-command = "odoo-forge"
-args = ["mcp", "flowus"]
+command = "npx"
+args = ["-y", "flowus-mcp-server@latest"]
+env = { FLOWUS_TOKEN = "${token}" }
 ${CODEX_END_MARKER}`;
 }
 
@@ -33,33 +34,27 @@ export function upsertManagedBlock({
   return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
 }
 
-function ensureDirectoryLink({ linkPath, targetPath, platform = process.platform }) {
-  fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+export function readCodexManagedToken({ homeDir }) {
+  const configPath = getCodexConfigPath({ homeDir });
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
 
-  if (fs.existsSync(linkPath) || fs.lstatSync(path.dirname(linkPath)).isDirectory()) {
-    try {
-      const existingTarget = fs.readlinkSync(linkPath);
-      if (path.resolve(path.dirname(linkPath), existingTarget) === targetPath) {
-        return;
-      }
-    } catch {
-      fs.rmSync(linkPath, { force: true, recursive: true });
-    }
+  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) {
+    return null;
   }
 
-  fs.rmSync(linkPath, { force: true, recursive: true });
-  fs.symlinkSync(targetPath, linkPath, platform === "win32" ? "junction" : "dir");
+  const managedBlock = content.slice(startIndex, endIndex + CODEX_END_MARKER.length);
+  const match = managedBlock.match(/FLOWUS_TOKEN\s*=\s*"([^"]+)"/);
+  return match?.[1] ?? null;
 }
 
-export function installCodexWiring({
-  homeDir,
-  installRoot,
-  platform = process.platform,
-}) {
+export function installCodexWiring({ homeDir, token }) {
   const configPath = getCodexConfigPath({ homeDir });
-  const linkPath = getCodexSkillsLinkPath({ homeDir });
   const codexDir = path.dirname(configPath);
-  const skillsTarget = path.join(installRoot, "current", "skills");
 
   fs.mkdirSync(codexDir, { recursive: true });
   const currentConfig = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
@@ -67,14 +62,11 @@ export function installCodexWiring({
     originalContent: currentConfig,
     startMarker: CODEX_START_MARKER,
     endMarker: CODEX_END_MARKER,
-    block: buildCodexManagedBlock(),
+    block: buildCodexManagedBlock({ token }),
   });
   fs.writeFileSync(configPath, nextConfig);
 
-  ensureDirectoryLink({ linkPath, targetPath: skillsTarget, platform });
-
   return {
     configPath,
-    linkPath,
   };
 }

package/src/index.js

@@ -2,20 +2,17 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline/promises";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
+import { installClaudeWiring, readClaudeManagedToken } from "./claude.js";
+import { installCodexWiring, readCodexManagedToken } from "./codex.js";
 import {
-  getConfigPath,
-  getFlowusToken,
-  readUserConfig,
-  writeFlowusToken,
-  writeState,
-} from "./config.js";
-import { buildClaudeCommandPlan, renderClaudeMarketplace } from "./claude.js";
-import { installCodexWiring } from "./codex.js";
-import { getCurrentRoot, getInstallRoot, getStatePath } from "./paths.js";
-import { installRuntime } from "./runtime.js";
+  getAgentsSkillsRoot,
+  getClaudeConfigPath,
+  getCodexConfigPath,
+  getInstalledSkillsPath,
+} from "./paths.js";
 
 function printHelp() {
   console.log(`Odoo Forge CLI
@@ -56,17 +53,6 @@ async function defaultPromptForSecret(message) {
   }
 }
 
-async function defaultRunCommand(command, args, options = {}) {
-  return await new Promise((resolve) => {
-    const child = spawn(command, args, {
-      stdio: "inherit",
-      ...options,
-    });
-    child.on("close", (code) => resolve({ code: code ?? 0 }));
-    child.on("error", () => resolve({ code: 1 }));
-  });
-}
-
 async function defaultSpawnProcess(command, args, options = {}) {
   return await new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -78,22 +64,25 @@ async function defaultSpawnProcess(command, args, options = {}) {
   });
 }
 
-async function defaultHasCommand(command) {
-  const result = spawnSync(command, ["--version"], { stdio: "ignore" });
-  return result.status === 0 || result.status === 1;
-}
+function installSkills({ bundleRoot, homeDir }) {
+  const sourceSkillsDir = path.join(bundleRoot, "skills");
+  const targetSkillsDir = getInstalledSkillsPath({ homeDir });
 
-async function readProduct(bundleRoot) {
-  return JSON.parse(fs.readFileSync(path.join(bundleRoot, "config", "product.json"), "utf8"));
+  fs.mkdirSync(getAgentsSkillsRoot({ homeDir }), { recursive: true });
+  fs.rmSync(targetSkillsDir, { recursive: true, force: true });
+  fs.cpSync(sourceSkillsDir, targetSkillsDir, { recursive: true });
+
+  return targetSkillsDir;
 }
 
-async function ensureFlowusToken({ ctx, configPath }) {
-  const existingConfig = readUserConfig({ configPath });
-  const envToken = ctx.env.ODOO_FORGE_FLOWUS_TOKEN;
-  const currentToken = envToken || getFlowusToken({ config: existingConfig });
+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) {
-    writeFlowusToken({ configPath, token: currentToken });
     return currentToken;
   }
 
@@ -102,103 +91,47 @@ async function ensureFlowusToken({ ctx, configPath }) {
   if (!token) {
     throw new Error("FlowUS token is required.");
   }
-  writeFlowusToken({ configPath, token });
   return token;
 }
 
-async function installClaude({ ctx, currentRoot, version, mode }) {
-  if (!(await ctx.hasCommand("claude"))) {
-    ctx.output.log("Claude CLI not found. Skipping Claude installation.");
-    return { enabled: false };
-  }
-
-  const marketplaceDir = renderClaudeMarketplace({
-    bundleRoot: currentRoot,
-    destinationRoot: currentRoot,
-    version,
-  });
-  const commandPlan = buildClaudeCommandPlan({ marketplaceDir, mode });
-
-  for (const step of commandPlan) {
-    const result = await ctx.runCommand(step.command, step.args);
-    if (result.code !== 0) {
-      throw new Error(
-        `Claude command failed: ${step.command} ${step.args.join(" ")}`,
-      );
-    }
-  }
-
-  return {
-    enabled: true,
-    marketplaceDir,
-  };
-}
-
 function runDoctor(ctx) {
-  const installRoot = getInstallRoot({ homeDir: ctx.homeDir });
-  const statePath = getStatePath({ homeDir: ctx.homeDir, installRoot });
-  const configPath = getConfigPath({
-    homeDir: ctx.homeDir,
-    platform: ctx.platform,
-    env: ctx.env,
-  });
-  const config = readUserConfig({ configPath });
-  const currentRoot = getCurrentRoot({ homeDir: ctx.homeDir, installRoot });
+  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(`Install root: ${installRoot}`);
-  ctx.output.log(`Install root exists: ${fs.existsSync(installRoot) ? "yes" : "no"}`);
-  ctx.output.log(`State file exists: ${fs.existsSync(statePath) ? "yes" : "no"}`);
-  ctx.output.log(`Config file exists: ${fs.existsSync(configPath) ? "yes" : "no"}`);
-  ctx.output.log(`FlowUS token exists: ${getFlowusToken({ config }) ? "yes" : "no"}`);
-  ctx.output.log(`Current runtime exists: ${fs.existsSync(currentRoot) ? "yes" : "no"}`);
-  ctx.output.log(
-    `Claude marketplace exists: ${fs.existsSync(path.join(currentRoot, "claude-marketplace")) ? "yes" : "no"}`,
-  );
+  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"}`);
 }
 
 async function runInstallLike(ctx, mode) {
-  const installRoot = getInstallRoot({ homeDir: ctx.homeDir });
-  const configPath = getConfigPath({
-    homeDir: ctx.homeDir,
-    platform: ctx.platform,
-    env: ctx.env,
-  });
   const bundleRoot = await resolveBundleRoot(ctx.bundleRoot);
-  const product = await readProduct(bundleRoot);
-
-  await ensureFlowusToken({ ctx, configPath });
-  const { currentRoot } = installRuntime({
+  const token = await ensureFlowusToken({ ctx });
+  const skillsPath = installSkills({
     bundleRoot,
-    installRoot,
-    version: product.version,
     homeDir: ctx.homeDir,
   });
 
-  installCodexWiring({
+  const codexResult = installCodexWiring({
     homeDir: ctx.homeDir,
-    installRoot,
-    platform: ctx.platform,
+    token,
   });
-
-  const claudeResult = await installClaude({
-    ctx,
-    currentRoot,
-    version: product.version,
-    mode,
-  });
-
-  writeState({
-    statePath: getStatePath({ homeDir: ctx.homeDir, installRoot }),
-    state: {
-      version: product.version,
-      installedAt: new Date().toISOString(),
-      claudeEnabled: claudeResult.enabled,
-    },
+  const claudeResult = installClaudeWiring({
+    homeDir: ctx.homeDir,
+    token,
   });
 
   ctx.output.log(`${mode} complete.`);
-  ctx.output.log(`Install root: ${installRoot}`);
+  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) {
@@ -206,21 +139,26 @@ async function runLogin(ctx, provider) {
     throw new Error(`Unsupported provider: ${provider}`);
   }
 
-  const configPath = getConfigPath({
-    homeDir: ctx.homeDir,
-    platform: ctx.platform,
-    env: ctx.env,
-  });
   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.");
   }
 
-  writeFlowusToken({ configPath, token });
-  ctx.output.log(`Saved FlowUS token to ${configPath}`);
+  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) {
@@ -228,16 +166,10 @@ async function runMcp(ctx, provider) {
     throw new Error(`Unsupported MCP provider: ${provider}`);
   }
 
-  const configPath = getConfigPath({
-    homeDir: ctx.homeDir,
-    platform: ctx.platform,
-    env: ctx.env,
-  });
-  const config = readUserConfig({ configPath });
-  const token = getFlowusToken({ config });
+  const token = ctx.env.FLOWUS_TOKEN ?? ctx.env.ODOO_FORGE_FLOWUS_TOKEN;
 
   if (!token) {
-    throw new Error("Missing FlowUS token. Run `odoo-forge login flowus` first.");
+    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"], {
@@ -256,9 +188,7 @@ function normalizeContext(overrides = {}) {
     bundleRoot: overrides.bundleRoot,
     output: overrides.output ?? console,
     promptForSecret: overrides.promptForSecret ?? defaultPromptForSecret,
-    runCommand: overrides.runCommand ?? defaultRunCommand,
     spawnProcess: overrides.spawnProcess ?? defaultSpawnProcess,
-    hasCommand: overrides.hasCommand ?? defaultHasCommand,
   };
 }
 

package/src/paths.js

@@ -1,26 +1,18 @@
 import os from "node:os";
 import path from "node:path";
 
-export function getInstallRoot({ homeDir = os.homedir() } = {}) {
-  return path.join(homeDir, ".odoo-forge");
-}
-
-export function getCurrentRoot({ homeDir = os.homedir(), installRoot } = {}) {
-  return path.join(installRoot ?? getInstallRoot({ homeDir }), "current");
-}
-
-export function getVersionsRoot({ homeDir = os.homedir(), installRoot } = {}) {
-  return path.join(installRoot ?? getInstallRoot({ homeDir }), "versions");
+export function getCodexConfigPath({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".codex", "config.toml");
 }
 
-export function getStatePath({ homeDir = os.homedir(), installRoot } = {}) {
-  return path.join(installRoot ?? getInstallRoot({ homeDir }), "state.json");
+export function getClaudeConfigPath({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".claude.json");
 }
 
-export function getCodexConfigPath({ homeDir = os.homedir() } = {}) {
-  return path.join(homeDir, ".codex", "config.toml");
+export function getAgentsSkillsRoot({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".agents", "skills");
 }
 
-export function getCodexSkillsLinkPath({ homeDir = os.homedir() } = {}) {
+export function getInstalledSkillsPath({ homeDir = os.homedir() } = {}) {
   return path.join(homeDir, ".agents", "skills", "odoo-forge");
 }

package/src/config.js

@@ -1,70 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-function readJsonFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return {};
-  }
-
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function writeJsonFile(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
-}
-
-export function getConfigPath({
-  homeDir = os.homedir(),
-  platform = process.platform,
-  env = process.env,
-} = {}) {
-  if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Application Support", "Odoo Forge", "config.json");
-  }
-
-  if (platform === "win32") {
-    const appData = env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
-    return path.win32.join(appData, "Odoo Forge", "config.json");
-  }
-
-  return path.join(homeDir, ".config", "Odoo Forge", "config.json");
-}
-
-export function readUserConfig({ configPath }) {
-  return readJsonFile(configPath);
-}
-
-export function writeUserConfig({ configPath, config }) {
-  writeJsonFile(configPath, config);
-}
-
-export function writeFlowusToken({ configPath, token }) {
-  const current = readUserConfig({ configPath });
-  const next = {
-    ...current,
-    mcp: {
-      ...(current.mcp ?? {}),
-      flowus: {
-        ...((current.mcp ?? {}).flowus ?? {}),
-        FLOWUS_TOKEN: token,
-      },
-    },
-  };
-
-  writeUserConfig({ configPath, config: next });
-  return next;
-}
-
-export function getFlowusToken({ config }) {
-  return config?.mcp?.flowus?.FLOWUS_TOKEN;
-}
-
-export function readState({ statePath }) {
-  return readJsonFile(statePath);
-}
-
-export function writeState({ statePath, state }) {
-  writeJsonFile(statePath, state);
-}

package/src/runtime.js

@@ -1,27 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-import { getCurrentRoot, getVersionsRoot } from "./paths.js";
-
-export function installRuntime({
-  bundleRoot,
-  installRoot,
-  version,
-  homeDir,
-}) {
-  const versionsRoot = getVersionsRoot({ homeDir, installRoot });
-  const currentRoot = getCurrentRoot({ homeDir, installRoot });
-  const versionRoot = path.join(versionsRoot, version);
-
-  fs.mkdirSync(versionsRoot, { recursive: true });
-  fs.rmSync(versionRoot, { force: true, recursive: true });
-  fs.cpSync(bundleRoot, versionRoot, { recursive: true });
-
-  fs.rmSync(currentRoot, { force: true, recursive: true });
-  fs.cpSync(versionRoot, currentRoot, { recursive: true });
-
-  return {
-    currentRoot,
-    versionRoot,
-  };
-}