@gricha/perry 0.0.1

package/dist/docker/index.js

@@ -0,0 +1,372 @@
+import { spawn } from 'child_process';
+export * from './types';
+const CONTAINER_PREFIX = 'workspace-';
+export function getContainerName(name) {
+    return `${CONTAINER_PREFIX}${name}`;
+}
+async function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const result = { stdout: stdout.trim(), stderr: stderr.trim(), code: code ?? 1 };
+            if (code === 0) {
+                resolve(result);
+            }
+            else {
+                const err = new Error(`Command failed: ${command} ${args.join(' ')}`);
+                err.code = code ?? undefined;
+                err.stdout = stdout;
+                err.stderr = stderr;
+                reject(err);
+            }
+        });
+    });
+}
+async function docker(args) {
+    return runCommand('docker', args);
+}
+export async function getDockerVersion() {
+    const { stdout } = await docker(['version', '--format', '{{.Server.Version}}']);
+    return stdout;
+}
+export async function containerExists(name) {
+    const { stdout } = await docker(['ps', '-a', '-q', '--filter', `name=^${name}$`]);
+    return stdout.length > 0;
+}
+export async function containerRunning(name) {
+    const { stdout } = await docker([
+        'ps',
+        '-q',
+        '--filter',
+        `name=^${name}$`,
+        '--filter',
+        'status=running',
+    ]);
+    return stdout.length > 0;
+}
+export async function getContainer(name) {
+    try {
+        const { stdout } = await docker(['inspect', '--format', '{{json .}}', name]);
+        const data = JSON.parse(stdout);
+        const portMappings = [];
+        const networkSettings = data.NetworkSettings?.Ports || {};
+        for (const [containerPort, hostBindings] of Object.entries(networkSettings)) {
+            if (!hostBindings)
+                continue;
+            const [port, protocol] = containerPort.split('/');
+            for (const binding of hostBindings) {
+                portMappings.push({
+                    containerPort: parseInt(port, 10),
+                    hostPort: parseInt(binding.HostPort, 10),
+                    protocol: protocol,
+                });
+            }
+        }
+        return {
+            id: data.Id,
+            name: data.Name.replace(/^\//, ''),
+            image: data.Config.Image,
+            status: data.State.Status,
+            state: data.State.Running ? 'running' : data.State.Status,
+            ports: portMappings,
+        };
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such object') && !stderr.includes('no such container')) {
+            console.error(`[docker] Error getting container '${name}':`, stderr);
+        }
+        return null;
+    }
+}
+export async function getContainerIp(name) {
+    try {
+        const { stdout } = await docker([
+            'inspect',
+            '--format',
+            '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}',
+            name,
+        ]);
+        const ip = stdout.trim();
+        return ip || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function listContainers(prefix) {
+    const args = ['ps', '-a', '--format', '{{json .}}'];
+    if (prefix) {
+        args.push('--filter', `name=^${prefix}`);
+    }
+    const { stdout } = await docker(args);
+    if (!stdout)
+        return [];
+    const containers = [];
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        const data = JSON.parse(line);
+        containers.push({
+            id: data.ID,
+            name: data.Names,
+            image: data.Image,
+            status: data.Status,
+            state: data.State.toLowerCase(),
+            ports: [],
+        });
+    }
+    return containers;
+}
+export async function createContainer(options) {
+    const args = ['create'];
+    if (options.name) {
+        args.push('--name', options.name);
+    }
+    if (options.hostname) {
+        args.push('--hostname', options.hostname);
+    }
+    if (options.privileged) {
+        args.push('--privileged');
+    }
+    if (options.network) {
+        args.push('--network', options.network);
+    }
+    if (options.workdir) {
+        args.push('--workdir', options.workdir);
+    }
+    if (options.user) {
+        args.push('--user', options.user);
+    }
+    if (options.restartPolicy) {
+        args.push('--restart', options.restartPolicy);
+    }
+    if (options.env) {
+        for (const [key, value] of Object.entries(options.env)) {
+            args.push('-e', `${key}=${value}`);
+        }
+    }
+    if (options.volumes) {
+        for (const vol of options.volumes) {
+            const mode = vol.readonly ? 'ro' : 'rw';
+            args.push('-v', `${vol.source}:${vol.target}:${mode}`);
+        }
+    }
+    if (options.ports) {
+        for (const port of options.ports) {
+            args.push('-p', `${port.hostPort}:${port.containerPort}/${port.protocol}`);
+        }
+    }
+    if (options.labels) {
+        for (const [key, value] of Object.entries(options.labels)) {
+            args.push('--label', `${key}=${value}`);
+        }
+    }
+    if (options.entrypoint) {
+        args.push('--entrypoint', options.entrypoint.join(' '));
+    }
+    args.push(options.image);
+    if (options.command) {
+        args.push(...options.command);
+    }
+    const { stdout } = await docker(args);
+    return stdout.trim();
+}
+export async function startContainer(name) {
+    await docker(['start', name]);
+}
+export async function stopContainer(name, timeout = 10) {
+    await docker(['stop', '-t', String(timeout), name]);
+}
+export async function removeContainer(name, force = false) {
+    const args = ['rm'];
+    if (force)
+        args.push('-f');
+    args.push(name);
+    await docker(args);
+}
+export async function execInContainer(name, command, options = {}) {
+    const args = ['exec'];
+    if (options.user) {
+        args.push('-u', options.user);
+    }
+    if (options.workdir) {
+        args.push('-w', options.workdir);
+    }
+    if (options.env) {
+        for (const [key, value] of Object.entries(options.env)) {
+            args.push('-e', `${key}=${value}`);
+        }
+    }
+    args.push(name, ...command);
+    try {
+        const result = await docker(args);
+        return { ...result, exitCode: 0 };
+    }
+    catch (err) {
+        const cmdErr = err;
+        return {
+            stdout: cmdErr.stdout || '',
+            stderr: cmdErr.stderr || '',
+            code: cmdErr.code || 1,
+            exitCode: cmdErr.code || 1,
+        };
+    }
+}
+export async function copyToContainer(containerName, sourcePath, destPath) {
+    await docker(['cp', sourcePath, `${containerName}:${destPath}`]);
+}
+export async function copyFromContainer(containerName, sourcePath, destPath) {
+    await docker(['cp', `${containerName}:${sourcePath}`, destPath]);
+}
+export async function volumeExists(name) {
+    try {
+        await docker(['volume', 'inspect', name]);
+        return true;
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such volume')) {
+            console.error(`[docker] Error checking volume '${name}':`, stderr);
+        }
+        return false;
+    }
+}
+export async function createVolume(name) {
+    await docker(['volume', 'create', name]);
+}
+export async function removeVolume(name, force = false) {
+    const args = ['volume', 'rm'];
+    if (force)
+        args.push('-f');
+    args.push(name);
+    await docker(args);
+}
+export async function getVolume(name) {
+    try {
+        const { stdout } = await docker(['volume', 'inspect', '--format', '{{json .}}', name]);
+        const data = JSON.parse(stdout);
+        return {
+            name: data.Name,
+            driver: data.Driver,
+            mountpoint: data.Mountpoint,
+        };
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such volume')) {
+            console.error(`[docker] Error getting volume '${name}':`, stderr);
+        }
+        return null;
+    }
+}
+export async function networkExists(name) {
+    try {
+        await docker(['network', 'inspect', name]);
+        return true;
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such network')) {
+            console.error(`[docker] Error checking network '${name}':`, stderr);
+        }
+        return false;
+    }
+}
+export async function createNetwork(name) {
+    await docker(['network', 'create', name]);
+}
+export async function removeNetwork(name) {
+    await docker(['network', 'rm', name]);
+}
+export async function getNetwork(name) {
+    try {
+        const { stdout } = await docker(['network', 'inspect', '--format', '{{json .}}', name]);
+        const data = JSON.parse(stdout);
+        return {
+            name: data.Name,
+            id: data.Id,
+            driver: data.Driver,
+        };
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such network')) {
+            console.error(`[docker] Error getting network '${name}':`, stderr);
+        }
+        return null;
+    }
+}
+export async function connectToNetwork(containerName, networkName) {
+    try {
+        await docker(['network', 'connect', networkName, containerName]);
+    }
+    catch (err) {
+        const message = err.stderr || '';
+        if (!message.includes('already exists in network')) {
+            throw err;
+        }
+    }
+}
+export async function imageExists(tag) {
+    try {
+        await docker(['image', 'inspect', tag]);
+        return true;
+    }
+    catch (err) {
+        const stderr = err.stderr?.toLowerCase() || '';
+        if (!stderr.includes('no such image')) {
+            console.error(`[docker] Error checking image '${tag}':`, stderr);
+        }
+        return false;
+    }
+}
+export async function pullImage(tag) {
+    await docker(['pull', tag]);
+}
+export async function buildImage(tag, context, options = {}) {
+    const args = ['build', '-t', tag];
+    if (options.noCache) {
+        args.push('--no-cache');
+    }
+    args.push(context);
+    return new Promise((resolve, reject) => {
+        const child = spawn('docker', args, {
+            stdio: ['ignore', 'inherit', 'inherit'],
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Docker build failed with exit code ${code}`));
+            }
+        });
+    });
+}
+export async function getLogs(containerName, options = {}) {
+    const args = ['logs'];
+    if (options.tail) {
+        args.push('--tail', String(options.tail));
+    }
+    if (options.since) {
+        args.push('--since', options.since);
+    }
+    args.push(containerName);
+    const { stdout, stderr } = await docker(args);
+    return stdout + stderr;
+}

package/dist/docker/types.js

@@ -0,0 +1 @@
+export {};