platxa-sidecar-builder

Build Node.js sidecar services for real-time code editing platforms. Covers file watching, git operations, WebSocket servers, Yjs CRDT integration, REST APIs, and Kubernetes deployment patterns.

설치로 이동

저장소: platxa/platxa-skill-generator
최근 소스 활동: 2026년 4월 3일 14:15
감지된 SKILL.md 언어: 영어
스타: 4
포크: 0

설치 방법

기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.

Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.

직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.

npx skills add https://github.com/platxa/platxa-skill-generator --skill platxa-sidecar-builder

명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.

로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.

소스 파일 검토

설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.

파일 탐색기

4 개 파일

SKILL.md

소스 지침 · 읽기 전용 미리보기

검색으로 돌아가기 설치로 돌아가기

platxa-skill-generator

Autonomous skill creator for Claude Code CLI. Use when the user asks to "create a skill", "generate a skill", or "build a new slash command". Uses multi-phase orchestrated workflow with Task tool subagents to research domains, design architecture, generate content, validate quality, and iteratively improve via eval infrastructure. Creates production-ready skills following the Agent Skills open standard and Claude Code extensions.

2026-04-05

code-documenter

Automatically generates and improves code documentation across Python, JavaScript/TypeScript, Java, Go, and Rust. Detects language conventions, applies appropriate docstring standards, and validates documentation quality.

2026-04-03

commit-message

Generate conventional commit messages by analyzing staged git changes. Detects change type, suggests scope, and formats messages following the Conventional Commits specification.

2026-04-03

이 저장소의 모든 Skills 보기

sidecar/
├── src/
│   ├── index.ts           # Entry point
│   ├── file-watcher.ts    # Chokidar integration
│   ├── git-service.ts     # Git operations
│   ├── websocket-server.ts # ws server
│   ├── yjs-service.ts     # Yjs CRDT sync
│   ├── api.ts             # Fastify REST API
│   ├── process-manager.ts # Child process handling
│   └── logging.ts         # Pino structured logging
├── package.json
├── tsconfig.json
└── Dockerfile

// src/index.ts
import { FileWatcher } from './file-watcher';
import { GitService } from './git-service';
import { WebSocketServer } from './websocket-server';
import { YjsService } from './yjs-service';
import { createApiServer } from './api';
import { logger } from './logging';

async function main() {
  const workspacePath = process.env.WORKSPACE_PATH || '/workspace';
  const apiPort = parseInt(process.env.API_PORT || '3000');
  const wsPort = parseInt(process.env.WS_PORT || '3001');

  // Initialize services
  const gitService = new GitService(workspacePath);
  const yjsService = new YjsService();
  const wsServer = new WebSocketServer(wsPort, yjsService);
  const fileWatcher = new FileWatcher({
    workspacePath,
    ignored: ['**/node_modules', '**/.git', '**/__pycache__'],
  });

  await gitService.initialize();
  await wsServer.start();

  // File changes trigger Yjs updates
  fileWatcher.onChange(async (path, type) => {
    if (type === 'change' || type === 'add') {
      const content = await fs.promises.readFile(
        `${workspacePath}/${path}`, 'utf-8'
      );
      yjsService.reconcileWithFile(path, content);
      wsServer.broadcast({ type: 'file-changed', path });
    }
  });

  // Start REST API
  await createApiServer(apiPort, { gitService, yjsService, fileWatcher });

  logger.info({ workspacePath, apiPort, wsPort }, 'Sidecar started');

  // Graceful shutdown
  process.on('SIGTERM', async () => {
    logger.info('Shutting down...');
    await fileWatcher.close();
    await wsServer.stop();
    process.exit(0);
  });
}

main().catch((error) => {
  logger.fatal({ error }, 'Startup failed');
  process.exit(1);
});

// src/file-watcher.ts
import chokidar from 'chokidar';
import { logger } from './logging';

interface WatcherConfig {
  workspacePath: string;
  ignored?: string[];
}

export class FileWatcher {
  private watcher: chokidar.FSWatcher;
  private debounceTimers = new Map<string, NodeJS.Timeout>();

  constructor(config: WatcherConfig) {
    this.watcher = chokidar.watch(config.workspacePath, {
      persistent: true,
      ignored: config.ignored || [],
      awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
      alwaysStat: true,
    });
  }

  onChange(callback: (path: string, type: 'add' | 'change' | 'unlink') => void) {
    const debounced = (path: string, type: 'add' | 'change' | 'unlink') => {
      if (this.debounceTimers.has(path)) {
        clearTimeout(this.debounceTimers.get(path)!);
      }
      this.debounceTimers.set(path, setTimeout(() => {
        callback(path, type);
        this.debounceTimers.delete(path);
      }, 300));
    };

    this.watcher.on('add', (path) => debounced(path, 'add'));
    this.watcher.on('change', (path) => debounced(path, 'change'));
    this.watcher.on('unlink', (path) => debounced(path, 'unlink'));
    return this;
  }

  async close() {
    for (const timer of this.debounceTimers.values()) clearTimeout(timer);
    await this.watcher.close();
  }
}

// src/git-service.ts
import { simpleGit, SimpleGit } from 'simple-git';
import { logger } from './logging';

export class GitService {
  private git: SimpleGit;

  constructor(workspacePath: string) {
    this.git = simpleGit({ baseDir: workspacePath, timeout: 30000 });
  }

  async initialize() {
    await this.git.init();
    await this.git.addConfig('user.name', 'Platxa Editor');
    await this.git.addConfig('user.email', 'editor@platxa.local');
  }

  async commit(message: string): Promise<string> {
    await this.git.add('.');
    const result = await this.git.commit(message);
    logger.info({ commit: result.commit }, 'Committed');
    return result.commit;
  }

  async status() {
    return this.git.status();
  }

  async diff(path?: string) {
    return path ? this.git.diff([path]) : this.git.diff();
  }

  async log(count = 10) {
    return this.git.log({ maxCount: count });
  }
}

// src/websocket-server.ts
import WebSocket, { Server } from 'ws';
import { logger } from './logging';
import { YjsService } from './yjs-service';

export class WebSocketServer {
  private wss: Server;
  private clients = new Map<WebSocket, { id: string; lastPing: number }>();

  constructor(private port: number, private yjsService: YjsService) {
    this.wss = new Server({ port });
  }

  async start() {
    this.wss.on('connection', (ws, req) => {
      const clientId = `client_${Date.now()}`;
      this.clients.set(ws, { id: clientId, lastPing: Date.now() });

      logger.info({ clientId, total: this.clients.size }, 'Client connected');

      ws.on('message', (data) => this.handleMessage(ws, data));
      ws.on('close', () => this.handleClose(ws));
      ws.on('pong', () => {
        const client = this.clients.get(ws);
        if (client) client.lastPing = Date.now();
      });
    });

    // Heartbeat every 30s
    setInterval(() => {
      for (const [ws, client] of this.clients) {
        if (Date.now() - client.lastPing > 60000) {
          ws.terminate();
        } else {
          ws.ping();
        }
      }
    }, 30000);

    logger.info({ port: this.port }, 'WebSocket server started');
  }

  private handleMessage(ws: WebSocket, data: WebSocket.Data) {
    try {
      const msg = JSON.parse(data.toString());
      if (msg.type === 'yjs-update') {
        this.yjsService.applyUpdate(msg.docName, new Uint8Array(msg.update));
        this.broadcast(msg, ws);
      }
    } catch (error) {
      logger.error({ error }, 'Message handling failed');
    }
  }

  private handleClose(ws: WebSocket) {
    const client = this.clients.get(ws);
    this.clients.delete(ws);
    logger.info({ clientId: client?.id }, 'Client disconnected');
  }

  broadcast(message: any, exclude?: WebSocket) {
    const data = JSON.stringify(message);
    for (const [ws] of this.clients) {
      if (ws !== exclude && ws.readyState === WebSocket.OPEN) {
        ws.send(data);
      }
    }
  }

  async stop() {
    for (const [ws] of this.clients) ws.close();
    this.wss.close();
  }
}

# k8s/sidecar-pod.yaml
apiVersion: v1
kind: Pod
suggests:
  - platxa-logging
  - platxa-error-handling
  - platxa-testing
  - platxa-yjs-server
metadata:
  name: platxa-instance
spec:
  containers:
  - name: odoo
    image: odoo:18.0
    ports:
    - containerPort: 8069
    volumeMounts:
    - name: workspace
      mountPath: /mnt/addons

  initContainers:
  - name: editor-sync
    image: platxa/sidecar:latest
    restartPolicy: Always  # Native sidecar (K8s 1.33+)
    ports:
    - containerPort: 3000  # REST API
    - containerPort: 3001  # WebSocket
    env:
    - name: WORKSPACE_PATH
      value: /mnt/addons
    - name: API_PORT
      value: "3000"
    - name: WS_PORT
      value: "3001"
    volumeMounts:
    - name: workspace
      mountPath: /mnt/addons

  volumes:
  - name: workspace
    emptyDir: {}

// Minimal sidecar with file watching and REST API
import Fastify from 'fastify';
import chokidar from 'chokidar';
import fs from 'fs/promises';

const app = Fastify({ logger: true });
const workspace = process.env.WORKSPACE_PATH || '/workspace';

// File watcher
const watcher = chokidar.watch(workspace, {
  ignored: ['**/node_modules', '**/.git'],
  awaitWriteFinish: { stabilityThreshold: 500 },
});

watcher.on('change', (path) => {
  app.log.info({ path }, 'File changed');
});

// REST endpoints
app.get('/files', async () => {
  const files = await fs.readdir(workspace, { recursive: true });
  return { files };
});

app.get('/files/:path', async (req) => {
  const content = await fs.readFile(`${workspace}/${req.params.path}`, 'utf-8');
  return { content };
});

app.put('/files/:path', async (req) => {
  await fs.writeFile(`${workspace}/${req.params.path}`, req.body.content);
  return { success: true };
});

await app.listen({ port: 3000, host: '0.0.0.0' });

import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

app.post('/deploy/:module', async (req) => {
  const { module } = req.params;

  try {
    // Commit changes first
    await gitService.commit(`Deploy ${module}`);

    // Reload module in Odoo
    const { stdout, stderr } = await execAsync(
      `odoo -c /etc/odoo/odoo.conf -u ${module} --stop-after-init`,
      { timeout: 60000 }
    );

    return { success: true, commit: await gitService.log(1) };
  } catch (error) {
    return { success: false, error: error.message };
  }
});

platxa-sidecar-builder

설치 방법

소스 파일 검토