odoo-forge 0.1.0

package/bin/odoo-forge.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from "../src/index.js";
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "odoo-forge",
+  "version": "0.1.0",
+  "description": "CLI installer and updater for Odoo Forge internal 1.0.",
+  "type": "module",
+  "dependencies": {
+    "odoo-forge-bundle": "0.1.0"
+  },
+  "bin": {
+    "odoo-forge": "bin/odoo-forge.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "start": "node bin/odoo-forge.js",
+    "doctor": "node bin/odoo-forge.js doctor",
+    "test": "node --test"
+  }
+}

package/src/claude.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const MARKETPLACE_NAME = "odoo-forge-marketplace";
+const PLUGIN_NAME = "odoo-forge";
+
+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");
+
+  fs.rmSync(marketplaceDir, { force: true, recursive: true });
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  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",
+      },
+    ],
+  });
+
+  writeJson(path.join(pluginDir, ".claude-plugin", "plugin.json"), {
+    name: PLUGIN_NAME,
+    description: "Internal Odoo Forge plugin for Claude Code.",
+    version,
+    author: {
+      name: "Internal Team",
+    },
+  });
+
+  writeJson(path.join(pluginDir, ".mcp.json"), {
+    mcpServers: {
+      flowus: {
+        type: "stdio",
+        command: "odoo-forge",
+        args: ["mcp", "flowus"],
+      },
+    },
+  });
+
+  fs.cpSync(skillsSource, path.join(pluginDir, "skills"), { recursive: true });
+
+  return marketplaceDir;
+}
+
+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"],
+    },
+  ];
+}

package/src/codex.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { getCodexConfigPath, getCodexSkillsLinkPath } from "./paths.js";
+
+export const CODEX_START_MARKER = "# BEGIN ODOO FORGE FLOWUS";
+export const CODEX_END_MARKER = "# END ODOO FORGE FLOWUS";
+
+export function buildCodexManagedBlock() {
+  return `${CODEX_START_MARKER}
+[mcp_servers.flowus]
+type = "stdio"
+command = "odoo-forge"
+args = ["mcp", "flowus"]
+${CODEX_END_MARKER}`;
+}
+
+export function upsertManagedBlock({
+  originalContent,
+  startMarker,
+  endMarker,
+  block,
+}) {
+  const startIndex = originalContent.indexOf(startMarker);
+  const endIndex = originalContent.indexOf(endMarker);
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const blockEnd = endIndex + endMarker.length;
+    return `${originalContent.slice(0, startIndex)}${block}${originalContent.slice(blockEnd)}`;
+  }
+
+  const trimmed = originalContent.trimEnd();
+  return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
+}
+
+function ensureDirectoryLink({ linkPath, targetPath, platform = process.platform }) {
+  fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+
+  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 });
+    }
+  }
+
+  fs.rmSync(linkPath, { force: true, recursive: true });
+  fs.symlinkSync(targetPath, linkPath, platform === "win32" ? "junction" : "dir");
+}
+
+export function installCodexWiring({
+  homeDir,
+  installRoot,
+  platform = process.platform,
+}) {
+  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") : "";
+  const nextConfig = upsertManagedBlock({
+    originalContent: currentConfig,
+    startMarker: CODEX_START_MARKER,
+    endMarker: CODEX_END_MARKER,
+    block: buildCodexManagedBlock(),
+  });
+  fs.writeFileSync(configPath, nextConfig);
+
+  ensureDirectoryLink({ linkPath, targetPath: skillsTarget, platform });
+
+  return {
+    configPath,
+    linkPath,
+  };
+}

package/src/config.js

@@ -0,0 +1,70 @@
+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/index.js

@@ -0,0 +1,295 @@
+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 { fileURLToPath } from "node:url";
+
+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";
+
+function printHelp() {
+  console.log(`Odoo Forge CLI
+
+Usage:
+  odoo-forge install
+  odoo-forge update
+  odoo-forge doctor
+  odoo-forge login flowus
+  odoo-forge mcp flowus`);
+}
+
+async function resolveBundleRoot(bundleRootOverride) {
+  if (bundleRootOverride) {
+    return bundleRootOverride;
+  }
+
+  try {
+    const bundle = await import("odoo-forge-bundle");
+    return bundle.getBundleRoot();
+  } catch {
+    return path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "../../odoo-forge-bundle/payload",
+    );
+  }
+}
+
+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 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, {
+      stdio: "inherit",
+      ...options,
+    });
+    child.on("close", (code) => resolve(code ?? 0));
+    child.on("error", reject);
+  });
+}
+
+async function defaultHasCommand(command) {
+  const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+  return result.status === 0 || result.status === 1;
+}
+
+async function readProduct(bundleRoot) {
+  return JSON.parse(fs.readFileSync(path.join(bundleRoot, "config", "product.json"), "utf8"));
+}
+
+async function ensureFlowusToken({ ctx, configPath }) {
+  const existingConfig = readUserConfig({ configPath });
+  const envToken = ctx.env.ODOO_FORGE_FLOWUS_TOKEN;
+  const currentToken = envToken || getFlowusToken({ config: existingConfig });
+
+  if (currentToken) {
+    writeFlowusToken({ configPath, token: currentToken });
+    return currentToken;
+  }
+
+  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.");
+  }
+  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 });
+
+  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"}`,
+  );
+}
+
+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({
+    bundleRoot,
+    installRoot,
+    version: product.version,
+    homeDir: ctx.homeDir,
+  });
+
+  installCodexWiring({
+    homeDir: ctx.homeDir,
+    installRoot,
+    platform: ctx.platform,
+  });
+
+  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,
+    },
+  });
+
+  ctx.output.log(`${mode} complete.`);
+  ctx.output.log(`Install root: ${installRoot}`);
+}
+
+async function runLogin(ctx, provider) {
+  if (provider !== "flowus") {
+    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 ??
+    (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}`);
+}
+
+async function runMcp(ctx, provider) {
+  if (provider !== "flowus") {
+    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 });
+
+  if (!token) {
+    throw new Error("Missing FlowUS token. Run `odoo-forge login flowus` first.");
+  }
+
+  return await ctx.spawnProcess("npx", ["-y", "flowus-mcp-server@latest"], {
+    env: {
+      ...ctx.env,
+      FLOWUS_TOKEN: token,
+    },
+  });
+}
+
+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,
+    runCommand: overrides.runCommand ?? defaultRunCommand,
+    spawnProcess: overrides.spawnProcess ?? defaultSpawnProcess,
+    hasCommand: overrides.hasCommand ?? defaultHasCommand,
+  };
+}
+
+export async function main(argv, overrides = {}) {
+  const ctx = normalizeContext(overrides);
+  const command = argv[0] ?? "help";
+
+  switch (command) {
+    case "install":
+      await runInstallLike(ctx, "install");
+      break;
+    case "update":
+      await runInstallLike(ctx, "update");
+      break;
+    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":
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exitCode = 1;
+  }
+}

package/src/paths.js

@@ -0,0 +1,26 @@
+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 getStatePath({ homeDir = os.homedir(), installRoot } = {}) {
+  return path.join(installRoot ?? getInstallRoot({ homeDir }), "state.json");
+}
+
+export function getCodexConfigPath({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".codex", "config.toml");
+}
+
+export function getCodexSkillsLinkPath({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".agents", "skills", "odoo-forge");
+}

package/src/runtime.js

@@ -0,0 +1,27 @@
+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,
+  };
+}