@y4wee/nupo 0.1.0

package/dist/services/checks.d.ts

@@ -0,0 +1,8 @@
+export interface CheckResult {
+    ok: boolean;
+    version?: string;
+    error?: string;
+}
+export declare function checkPython(): Promise<CheckResult>;
+export declare function checkPip(): Promise<CheckResult>;
+export declare function checkVenv(): Promise<CheckResult>;

package/dist/services/checks.js

@@ -0,0 +1,48 @@
+import { execFile } from 'node:child_process';
+function execFileAsync(cmd, args) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, (err, stdout, stderr) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+}
+async function tryCommand(cmd, args) {
+    try {
+        const { stdout, stderr } = await execFileAsync(cmd, args);
+        const output = (stdout || stderr).trim();
+        const versionMatch = output.match(/\d+\.\d+\.\d+/);
+        return { ok: true, version: versionMatch?.[0] };
+    }
+    catch (err) {
+        const error = err;
+        return { ok: false, error: error.message ?? String(err) };
+    }
+}
+export async function checkPython() {
+    const result = await tryCommand('python3', ['--version']);
+    if (result.ok)
+        return result;
+    return tryCommand('python', ['--version']);
+}
+export async function checkPip() {
+    const result = await tryCommand('pip3', ['--version']);
+    if (result.ok)
+        return result;
+    return tryCommand('pip', ['--version']);
+}
+export async function checkVenv() {
+    const result = await tryCommand('python3', ['-m', 'venv', '--help']);
+    if (result.ok)
+        return { ok: true };
+    const result2 = await tryCommand('python', ['-m', 'venv', '--help']);
+    if (result2.ok)
+        return { ok: true };
+    const hint = process.platform === 'darwin'
+        ? 'réinstallez Python via python.org ou brew install python3'
+        : 'sudo apt install python3-venv';
+    return { ok: false, error: `python venv non disponible (${hint})` };
+}

package/dist/services/config.d.ts

@@ -0,0 +1,11 @@
+import { NupoConfig } from '../types/index.js';
+declare function getConfigDir(): string;
+declare function getConfigPath(): string;
+export declare function configExists(): Promise<boolean>;
+export declare function readConfig(): Promise<NupoConfig>;
+export declare function writeConfig(config: NupoConfig): Promise<void>;
+export declare function patchConfig(partial: Partial<NupoConfig>): Promise<void>;
+export { getConfigPath, getConfigDir };
+export declare function getBaseConfPath(): string;
+export declare function ensureBaseConf(): Promise<void>;
+export declare function readBaseConf(): Promise<string>;

package/dist/services/config.js

@@ -0,0 +1,146 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFile, writeFile, mkdir, access, rename } from 'fs/promises';
+import { DEFAULT_CONFIG } from '../types/index.js';
+// Serialise all writes to prevent concurrent writeFile corruption
+let writeQueue = Promise.resolve();
+function getConfigDir() {
+    return join(process.env['NUPO_CONFIG_DIR'] ?? homedir(), '.nupo');
+}
+function getConfigPath() {
+    return join(getConfigDir(), 'config.json');
+}
+export async function configExists() {
+    try {
+        await access(getConfigPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readConfig() {
+    try {
+        const data = await readFile(getConfigPath(), 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function writeConfig(config) {
+    writeQueue = writeQueue.then(async () => {
+        const dir = getConfigDir();
+        const dest = getConfigPath();
+        const tmp = dest + '.tmp';
+        await mkdir(dir, { recursive: true });
+        await writeFile(tmp, JSON.stringify(config, null, 2), 'utf-8');
+        await rename(tmp, dest);
+    });
+    return writeQueue;
+}
+export async function patchConfig(partial) {
+    const current = await readConfig();
+    await writeConfig({ ...current, ...partial });
+}
+export { getConfigPath, getConfigDir };
+// ── Base Odoo conf ────────────────────────────────────────────────────────────
+export function getBaseConfPath() {
+    return join(getConfigDir(), 'odoo_base.conf');
+}
+function getOdooDataDir() {
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Odoo');
+    }
+    return join(homedir(), '.local', 'share', 'Odoo');
+}
+function getGeoIpPath() {
+    if (process.platform === 'darwin') {
+        return process.arch === 'arm64'
+            ? '/opt/homebrew/share/GeoIP/GeoLite2-City.mmdb'
+            : '/usr/local/share/GeoIP/GeoLite2-City.mmdb';
+    }
+    return '/usr/share/GeoIP/GeoLite2-City.mmdb';
+}
+function buildDefaultBaseConf() {
+    return `[options]
+csv_internal_sep = ,
+data_dir = ${getOdooDataDir()}
+db_host = False
+db_maxconn = 64
+db_name = False
+db_password = False
+db_port = False
+db_sslmode = prefer
+db_template = template0
+db_user = False
+dbfilter =
+demo = {}
+email_from = False
+from_filter = False
+geoip_database = ${getGeoIpPath()}
+gevent_port = 8077
+http_enable = True
+http_interface =
+http_port = 8017
+import_partial =
+limit_memory_hard = 2684354560
+limit_memory_soft = 2147483648
+limit_request = 65536
+limit_time_cpu = 6000
+limit_time_real = 1200
+limit_time_real_cron = -1
+list_db = True
+log_db = False
+log_db_level = warning
+log_handler = :INFO
+log_level = info
+logfile =
+max_cron_threads = 2
+osv_memory_age_limit = False
+osv_memory_count_limit = 0
+pg_path =
+pidfile =
+proxy_mode = False
+reportgz = False
+screencasts =
+screenshots = /tmp/odoo_tests
+server_wide_modules = base,web
+smtp_password = False
+smtp_port = 25
+smtp_server = localhost
+smtp_ssl = False
+smtp_ssl_certificate_filename = False
+smtp_ssl_private_key_filename = False
+smtp_user = False
+syslog = False
+test_enable = False
+test_file =
+test_tags = None
+transient_age_limit = 1.0
+translate_modules = ['all']
+unaccent = False
+upgrade_path =
+websocket_keep_alive_timeout = 3600
+websocket_rate_limit_burst = 10
+websocket_rate_limit_delay = 0.2
+without_demo = False
+workers = 0
+x_sendfile = False
+admin_passwd = admin
+`;
+}
+export async function ensureBaseConf() {
+    const path = getBaseConfPath();
+    try {
+        await access(path);
+    }
+    catch {
+        await mkdir(getConfigDir(), { recursive: true });
+        await writeFile(path, buildDefaultBaseConf(), 'utf-8');
+    }
+}
+export async function readBaseConf() {
+    await ensureBaseConf();
+    return readFile(getBaseConfPath(), 'utf-8');
+}

package/dist/services/git.d.ts

@@ -0,0 +1,35 @@
+export declare const ODOO_COMMUNITY_URL = "https://github.com/odoo/odoo.git";
+export declare const ODOO_ENTERPRISE_URL = "git@github.com:odoo/enterprise.git";
+export interface GitResult {
+    ok: boolean;
+    error?: string;
+}
+export interface GitProgress {
+    phase: 'receiving' | 'resolving';
+    percent: number;
+    speed?: string;
+}
+/**
+ * Check whether a branch exists on a remote git repository.
+ * Uses `git ls-remote` — no clone required.
+ */
+export declare function checkBranch(repoUrl: string, branch: string): Promise<GitResult>;
+/**
+ * Get the HEAD commit hash of a local git repository.
+ */
+export declare function getLocalCommit(repoPath: string): Promise<string | null>;
+/**
+ * Get the HEAD commit hash for a branch on a remote (via ls-remote).
+ */
+export declare function getRemoteCommit(repoUrl: string, branch: string): Promise<string | null>;
+/**
+ * Update a local shallow clone:
+ *   git fetch --depth 1 --progress origin <branch>  (stderr streamed for progress)
+ *   git reset --hard origin/<branch>
+ */
+export declare function updateRepo(repoPath: string, branch: string, onProgress?: (progress: GitProgress) => void): Promise<GitResult>;
+/**
+ * Clone a repository with --depth 1 (no full history).
+ * Streams stderr in real time to call onProgress with parsed progress info.
+ */
+export declare function cloneRepo(url: string, dest: string, branch: string, onProgress?: (progress: GitProgress) => void): Promise<GitResult>;

package/dist/services/git.js

@@ -0,0 +1,173 @@
+import { execFile, spawn } from 'node:child_process';
+export const ODOO_COMMUNITY_URL = 'https://github.com/odoo/odoo.git';
+// Enterprise is a private repo: use SSH so the user's key is used automatically.
+export const ODOO_ENTERPRISE_URL = 'git@github.com:odoo/enterprise.git';
+// GIT_TERMINAL_PROMPT=0 prevents git from hanging waiting for credential input
+// when there is no TTY (execFile / spawn have no TTY by default).
+// LC_ALL=C forces English output so progress line parsing works regardless of system locale.
+const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' };
+function execFileAsync(cmd, args, maxBuffer = 1024 * 1024, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, { maxBuffer, env: GIT_ENV, cwd: options.cwd }, (err, stdout, stderr) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+}
+/**
+ * Parse a single git progress line into a structured object.
+ * Git writes lines like:
+ *   "Receiving objects:  45% (5555/12345), 10.23 MiB | 3.14 MiB/s"
+ *   "Resolving deltas:   67% (1234/1844)"
+ */
+function parseGitProgress(line) {
+    const m = line.match(/^(Receiving objects|Resolving deltas):\s+(\d+)%[^|]*(?:\|\s*([\d.]+ \S+\/s))?/);
+    if (!m)
+        return null;
+    return {
+        phase: m[1] === 'Receiving objects' ? 'receiving' : 'resolving',
+        percent: parseInt(m[2], 10),
+        speed: m[3]?.trim(),
+    };
+}
+/**
+ * Check whether a branch exists on a remote git repository.
+ * Uses `git ls-remote` — no clone required.
+ */
+export async function checkBranch(repoUrl, branch) {
+    try {
+        const { stdout } = await execFileAsync('git', [
+            'ls-remote', '--heads', repoUrl, `refs/heads/${branch}`,
+        ]);
+        if (stdout.trim())
+            return { ok: true };
+        return { ok: false, error: `Branche "${branch}" introuvable dans le dépôt` };
+    }
+    catch (err) {
+        return { ok: false, error: err.message ?? String(err) };
+    }
+}
+/**
+ * Get the HEAD commit hash of a local git repository.
+ */
+export async function getLocalCommit(repoPath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], 1024 * 1024, { cwd: repoPath });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the HEAD commit hash for a branch on a remote (via ls-remote).
+ */
+export async function getRemoteCommit(repoUrl, branch) {
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-remote', repoUrl, `refs/heads/${branch}`]);
+        const hash = stdout.trim().split(/[\t\s]/)[0] ?? '';
+        return hash || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Update a local shallow clone:
+ *   git fetch --depth 1 --progress origin <branch>  (stderr streamed for progress)
+ *   git reset --hard origin/<branch>
+ */
+export function updateRepo(repoPath, branch, onProgress) {
+    return new Promise(resolve => {
+        const fetchProc = spawn('git', ['fetch', '--depth', '1', '--progress', 'origin', branch], { env: GIT_ENV, stdio: ['ignore', 'pipe', 'pipe'], cwd: repoPath });
+        let stderrFull = '';
+        fetchProc.stderr?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderrFull += text;
+            for (const part of text.split(/[\r\n]/)) {
+                const line = part.trim();
+                if (!line)
+                    continue;
+                const progress = parseGitProgress(line);
+                if (progress)
+                    onProgress?.(progress);
+            }
+        });
+        fetchProc.stdout?.resume();
+        let settled = false;
+        const done = (result) => {
+            if (!settled) {
+                settled = true;
+                resolve(result);
+            }
+        };
+        fetchProc.on('error', err => done({ ok: false, error: err.message }));
+        fetchProc.on('close', code => {
+            if (code !== 0) {
+                const errorMsg = stderrFull.split('\n').map(l => l.trim()).filter(l => /^(fatal|error):/i.test(l)).join(' · ') ||
+                    stderrFull.trim().split('\n').pop()?.trim() ||
+                    'Fetch échoué';
+                done({ ok: false, error: errorMsg });
+                return;
+            }
+            // fetch OK → reset --hard
+            execFileAsync('git', ['reset', '--hard', `origin/${branch}`], 1024 * 1024, { cwd: repoPath })
+                .then(() => done({ ok: true }))
+                .catch(err => done({ ok: false, error: err.message }));
+        });
+    });
+}
+/**
+ * Clone a repository with --depth 1 (no full history).
+ * Streams stderr in real time to call onProgress with parsed progress info.
+ */
+export function cloneRepo(url, dest, branch, onProgress) {
+    return new Promise(resolve => {
+        const proc = spawn('git', ['clone', '--depth', '1', '--branch', branch, '--progress', url, dest], { env: GIT_ENV, stdio: ['ignore', 'pipe', 'pipe'] });
+        // Collect stderr for error extraction; parse progress in real time
+        let stderrFull = '';
+        proc.stderr?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderrFull += text;
+            // Git uses \r to overwrite progress lines on the same terminal line.
+            // Split on both \r and \n to get individual lines.
+            for (const part of text.split(/[\r\n]/)) {
+                const line = part.trim();
+                if (!line)
+                    continue;
+                const progress = parseGitProgress(line);
+                if (progress)
+                    onProgress?.(progress);
+            }
+        });
+        // stdout is usually empty for git clone; drain it to avoid backpressure
+        proc.stdout?.resume();
+        let settled = false;
+        const done = (result) => {
+            if (!settled) {
+                settled = true;
+                resolve(result);
+            }
+        };
+        proc.on('error', err => done({ ok: false, error: err.message }));
+        proc.on('close', code => {
+            if (code === 0) {
+                done({ ok: true });
+            }
+            else {
+                // Extract the most meaningful line from stderr (fatal: / error: lines)
+                const errorMsg = stderrFull
+                    .split('\n')
+                    .map(l => l.trim())
+                    .filter(l => /^(fatal|error):/i.test(l))
+                    .join(' · ') ||
+                    stderrFull.trim().split('\n').pop()?.trim() ||
+                    'Clone échoué';
+                done({ ok: false, error: errorMsg });
+            }
+        });
+    });
+}

package/dist/services/ide.d.ts

@@ -0,0 +1,10 @@
+import { OdooVersion, OdooServiceConfig } from '../types/index.js';
+export type IdeStepId = 'vscode_dir' | 'settings_json' | 'launch_json' | 'open_vscode';
+export type IdeStepStatus = 'running' | 'success' | 'error';
+export type IdeStepCallback = (id: IdeStepId, status: IdeStepStatus, detail?: string) => void;
+/**
+ * Sets up .vscode/ for the given Odoo version and opens VS Code.
+ * Calls onStep for each step so callers can display progress (TUI or CLI).
+ * Returns true on success, false on any error.
+ */
+export declare function setupVsCode(version: OdooVersion, services: OdooServiceConfig[], onStep: IdeStepCallback): Promise<boolean>;

package/dist/services/ide.js

@@ -0,0 +1,126 @@
+import { mkdir, access, readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { spawn } from 'child_process';
+function buildAddonsPaths(service) {
+    const paths = [join(service.versionPath, 'community', 'addons')];
+    if (service.useEnterprise)
+        paths.push(join(service.versionPath, 'enterprise'));
+    for (const f of service.customFolders)
+        paths.push(join(service.versionPath, 'custom', f));
+    return paths;
+}
+function buildDebugConfig(service) {
+    return {
+        name: service.name,
+        type: 'debugpy',
+        request: 'launch',
+        stopOnEntry: false,
+        program: join(service.versionPath, 'community', 'odoo-bin'),
+        args: [
+            '--addons-path',
+            buildAddonsPaths(service).join(','),
+            '-c',
+            service.confPath,
+        ],
+        console: 'integratedTerminal',
+        justMyCode: true,
+        env: {
+            PYTHONPATH: '${workspaceFolder}',
+        },
+    };
+}
+// ── Main setup function ───────────────────────────────────────────────────────
+/**
+ * Sets up .vscode/ for the given Odoo version and opens VS Code.
+ * Calls onStep for each step so callers can display progress (TUI or CLI).
+ * Returns true on success, false on any error.
+ */
+export async function setupVsCode(version, services, onStep) {
+    const vscodeDir = join(version.path, '.vscode');
+    const settingsPath = join(vscodeDir, 'settings.json');
+    const launchPath = join(vscodeDir, 'launch.json');
+    // ── Step 1: .vscode directory ───────────────────────────────────────────────
+    onStep('vscode_dir', 'running');
+    try {
+        await mkdir(vscodeDir, { recursive: true });
+        onStep('vscode_dir', 'success');
+    }
+    catch (e) {
+        onStep('vscode_dir', 'error', String(e));
+        return false;
+    }
+    // ── Step 2: settings.json ───────────────────────────────────────────────────
+    onStep('settings_json', 'running');
+    try {
+        let exists = false;
+        try {
+            await access(settingsPath);
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            const content = {
+                'python.defaultInterpreterPath': '${workspaceFolder}/.venv/bin/python',
+                'python.terminal.activateEnvironment': true,
+            };
+            await writeFile(settingsPath, JSON.stringify(content, null, 4), 'utf-8');
+            onStep('settings_json', 'success', 'créé');
+        }
+        else {
+            onStep('settings_json', 'success', 'existant');
+        }
+    }
+    catch (e) {
+        onStep('settings_json', 'error', String(e));
+        return false;
+    }
+    // ── Step 3: launch.json ─────────────────────────────────────────────────────
+    onStep('launch_json', 'running');
+    try {
+        let launchData = { version: '0.2.0', configurations: [] };
+        try {
+            const raw = await readFile(launchPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            launchData.version = parsed.version ?? '0.2.0';
+            launchData.configurations = Array.isArray(parsed.configurations) ? parsed.configurations : [];
+        }
+        catch { }
+        const versionServices = services.filter(s => s.versionPath === version.path);
+        let added = 0;
+        for (const svc of versionServices) {
+            const alreadyExists = launchData.configurations.some(c => c.name === svc.name);
+            if (!alreadyExists) {
+                launchData.configurations.push(buildDebugConfig(svc));
+                added++;
+            }
+        }
+        await writeFile(launchPath, JSON.stringify(launchData, null, 4), 'utf-8');
+        const parts = [];
+        if (added)
+            parts.push(`${added} config(s) ajoutée(s)`);
+        if (!added && versionServices.length)
+            parts.push('configs déjà présentes');
+        if (!versionServices.length)
+            parts.push('aucun service pour cette version');
+        onStep('launch_json', 'success', parts.join(', '));
+    }
+    catch (e) {
+        onStep('launch_json', 'error', String(e));
+        return false;
+    }
+    // ── Step 4: open VS Code ────────────────────────────────────────────────────
+    onStep('open_vscode', 'running');
+    try {
+        await new Promise((resolve, reject) => {
+            const proc = spawn('code', [version.path], { detached: true, stdio: 'ignore' });
+            proc.on('error', reject);
+            setTimeout(() => { proc.unref(); resolve(); }, 200);
+        });
+        onStep('open_vscode', 'success');
+    }
+    catch {
+        onStep('open_vscode', 'error', 'code introuvable — vérifiez le PATH');
+        return false;
+    }
+    return true;
+}

package/dist/services/python.d.ts

@@ -0,0 +1,14 @@
+export interface PythonResult {
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Create a Python virtual environment at the given path.
+ * Tries python3 first, then python.
+ */
+export declare function createVenv(venvPath: string): Promise<PythonResult>;
+/**
+ * Install pip requirements from a requirements.txt file using the venv's pip.
+ * Streams stdout/stderr lines to onOutput for live feedback.
+ */
+export declare function installRequirements(pipPath: string, requirementsPath: string, onOutput?: (line: string) => void): Promise<PythonResult>;

package/dist/services/python.js

@@ -0,0 +1,81 @@
+import { execFile, spawn } from 'node:child_process';
+function execFileAsync(cmd, args) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, { maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                err.stderrOutput = String(stderr);
+                reject(err);
+                return;
+            }
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+}
+/**
+ * Create a Python virtual environment at the given path.
+ * Tries python3 first, then python.
+ */
+export async function createVenv(venvPath) {
+    const candidates = ['python3', 'python'];
+    for (const cmd of candidates) {
+        try {
+            await execFileAsync(cmd, ['-m', 'venv', venvPath]);
+            return { ok: true };
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT')
+                continue; // command not found, try next
+            const detail = e.stderrOutput?.trim() || e.message;
+            return { ok: false, error: detail };
+        }
+    }
+    return { ok: false, error: 'python3 / python introuvable sur ce système' };
+}
+/**
+ * Install pip requirements from a requirements.txt file using the venv's pip.
+ * Streams stdout/stderr lines to onOutput for live feedback.
+ */
+export function installRequirements(pipPath, requirementsPath, onOutput) {
+    return new Promise(resolve => {
+        const proc = spawn(pipPath, ['install', '-r', requirementsPath], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderrFull = '';
+        const handleChunk = (chunk) => {
+            for (const part of chunk.toString().split('\n')) {
+                const line = part.trim();
+                if (line)
+                    onOutput?.(line);
+            }
+        };
+        proc.stdout?.on('data', handleChunk);
+        proc.stderr?.on('data', (chunk) => {
+            stderrFull += chunk.toString();
+            handleChunk(chunk);
+        });
+        let settled = false;
+        const done = (result) => {
+            if (!settled) {
+                settled = true;
+                resolve(result);
+            }
+        };
+        proc.on('error', err => done({ ok: false, error: err.message }));
+        proc.on('close', code => {
+            if (code === 0) {
+                done({ ok: true });
+            }
+            else {
+                const errMsg = stderrFull
+                    .split('\n')
+                    .map(l => l.trim())
+                    .filter(l => /^(error|fatal):/i.test(l))
+                    .join(' · ') ||
+                    stderrFull.trim().split('\n').pop()?.trim() ||
+                    'Installation des dépendances échouée';
+                done({ ok: false, error: errMsg });
+            }
+        });
+    });
+}

package/dist/services/system.d.ts

@@ -0,0 +1,2 @@
+export declare function openInEditor(filePath: string): void;
+export declare function runInTerminal(cmd: string, args: string[]): void;