shadownrx-code 1.0.0

package/README.md

@@ -0,0 +1,130 @@
+# shadownrx-code
+
+Configurador interactivo de terminal para la plataforma de build de
+`shadownrx/code`. Detecta si tu proyecto es Flutter, React Native, una PWA
+(Capacitor) o Electron, te hace un par de preguntas, y te escribe
+`.github/workflows/build.yml` ya configurado — no compila nada localmente, solo
+prepara el workflow que corre gratis en GitHub Actions.
+
+```
+▲ shadownrx/code — configurador de CI para Android, iOS y Electron
+
+? Detecté un proyecto React Native en este directorio. ¿Es correcto? › Yes
+? ¿Qué deseas compilar? › Android + iOS (ambas)
+? ¿Ya tenés listos los secrets de firma (keystore / certificado de Apple)? › No
+? ¿Adjuntar los builds a un GitHub Release cuando pushees un tag (v1.2.3)? › No
+
+✔ Escribí .github/workflows/build.yml
+```
+
+Para Electron, la pregunta "¿Qué deseas compilar?" y la de firma no aparecen
+(Electron siempre compila Linux + macOS + Windows, y la firma todavía no está
+soportada) — solo pregunta el tipo de proyecto y si querés adjuntar a un
+GitHub Release.
+
+## Usar
+
+La idea es que, una vez publicado, alcance con:
+
+```bash
+npx shadownrx-code
+```
+
+parado en la raíz de tu proyecto (Flutter, React Native, PWA o Electron) — sin
+clonar nada. **Todavía no está publicado en npm** (publicarlo es distribuirlo
+públicamente, así que quedó pendiente de que lo pidas explícito — y hace falta
+una cuenta/token de npm que este entorno no tiene). El nombre `shadownrx-code`
+está libre en el registro — no se reserva hasta el primer `npm publish`.
+
+Mientras tanto, corré la versión local:
+
+```bash
+git clone https://github.com/shadownrx/code
+cd code/cli
+npm install
+node bin.js   # parado en la raíz de TU proyecto, o pasale el cwd que corresponda
+```
+
+o, apuntando directo a la carpeta de tu proyecto:
+
+```bash
+cd /ruta/a/tu/proyecto
+node /ruta/a/code/cli/bin.js
+```
+
+## Como tool de Cursor (o cualquier cliente MCP)
+
+Además del CLI interactivo, `mcp-server.js` expone lo mismo como un servidor
+[MCP](https://modelcontextprotocol.io) — así el agente de Cursor (o Claude
+Code, Windsurf, o cualquier editor con soporte MCP; no es algo específico de
+Cursor) puede llamarlo directamente en la conversación, sin que abras una
+terminal vos.
+
+Agregá esto a `.cursor/mcp.json` en tu proyecto (o al `mcp.json` global de
+Cursor):
+
+```json
+{
+  "mcpServers": {
+    "shadownrx-code": {
+      "command": "node",
+      "args": ["/ruta/absoluta/a/code/cli/mcp-server.js"]
+    }
+  }
+}
+```
+
+(Una vez publicado en npm, `"command": "npx", "args": ["-y", "shadownrx-code-mcp"]`
+alcanzaría, sin ruta absoluta ni clonar nada — mismo estado pendiente que el
+CLI, ver arriba.)
+
+Este mismo repo ya trae [`.cursor/mcp.json`](../.cursor/mcp.json) apuntando a
+`cli/mcp-server.js` con `${workspaceFolder}` — si abrís `shadownrx/code` en
+Cursor, la tool queda disponible sola. Eso sí, corré `npm install` en `cli/`
+primero (`node_modules` no se commitea): el server necesita
+`@modelcontextprotocol/sdk` y `zod` instalados para arrancar.
+
+Expone dos tools:
+
+| Tool | Qué hace |
+|---|---|
+| `detect_project_type` | Solo lee: reporta si un directorio es Flutter/React Native/PWA/Electron. No escribe nada. |
+| `setup_mobile_ci` | Detecta (o recibe `project_type` explícito) y escribe `.github/workflows/build.yml` — mismos parámetros que el CLI interactivo (`build_android`, `build_ios`, `build_electron`, `create_release`), más `overwrite` para confirmar si el archivo ya existe. |
+
+Ambas tools están probadas de punta a punta contra el server real (no un
+mock): `mcp-server.test.js` levanta `mcp-server.js` como subproceso vía stdio
+con el `Client` del SDK de MCP y llama las tools de verdad.
+
+## Qué pregunta y por qué
+
+Cada pregunta mapea 1 a 1 a un input real de
+[`build-mobile.yml`](../.github/workflows/build-mobile.yml) — no hay ninguna
+opción que prometa algo que la plataforma no haga. Ver
+[`docs/USAGE.md`](../docs/USAGE.md) para el detalle de cada input.
+
+| Pregunta | Input generado |
+|---|---|
+| Tipo de proyecto (auto-detectado o elegido) | `project_type` |
+| Qué compilar (Android / iOS / ambas) — no aplica a Electron | `build_android`, `build_ios` |
+| ¿Adjuntar a un GitHub Release en tags? | `create_release` (+ el bloque `permissions: contents: write` que necesita) |
+
+Para Electron, en vez de `build_android`/`build_ios` se emite
+`build_electron: true` (siempre compila los tres sistemas operativos).
+
+Si respondés que ya tenés los secrets de firma listos, te lista los nombres
+exactos que hay que cargar en GitHub y te manda a `docs/SIGNING.md` — no los
+pide ni los toca, esos siempre se configuran a mano como secrets de GitHub.
+
+Si `.github/workflows/build.yml` ya existe, pregunta antes de pisarlo.
+
+## Desarrollo
+
+`lib.js` tiene toda la lógica pura (detección de proyecto + generación del
+YAML) separada de `bin.js` (la parte interactiva con
+[`prompts`](https://www.npmjs.com/package/prompts)) y de `mcp-server.js` (el
+server MCP) — justamente para no duplicar la lógica y poder testearla sin
+simular una terminal ni un cliente MCP real:
+
+```bash
+npm test   # node --test — corre lib.test.js y mcp-server.test.js
+```

package/bin.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import prompts from 'prompts';
+import {
+  PROJECT_LABELS,
+  androidSecrets,
+  buildWorkflowYaml,
+  detectProjectType,
+  iosSecrets,
+} from './lib.js';
+
+const cwd = process.cwd();
+
+function onCancel() {
+  console.log('\nCancelado — no se modificó nada.\n');
+  process.exit(1);
+}
+
+async function main() {
+  console.log('\n▲ shadownrx/code — configurador de CI para Android, iOS y Electron\n');
+  console.log('Esto escribe .github/workflows/build.yml en este proyecto. No compila nada');
+  console.log('acá: el build corre gratis en GitHub Actions con cada push.\n');
+
+  const detected = detectProjectType(cwd);
+  let projectType = detected;
+
+  if (detected) {
+    const { confirmDetected } = await prompts(
+      {
+        type: 'confirm',
+        name: 'confirmDetected',
+        message: `Detecté un proyecto ${PROJECT_LABELS[detected]} en este directorio. ¿Es correcto?`,
+        initial: true,
+      },
+      { onCancel }
+    );
+    if (!confirmDetected) projectType = null;
+  }
+
+  if (!projectType) {
+    const { picked } = await prompts(
+      {
+        type: 'select',
+        name: 'picked',
+        message: '¿Qué tipo de proyecto es?',
+        choices: [
+          { title: 'Flutter', value: 'flutter' },
+          { title: 'React Native', value: 'react-native' },
+          { title: 'PWA (Capacitor)', value: 'pwa' },
+          { title: 'Electron', value: 'electron' },
+          { title: 'Detectar automáticamente en cada build', value: 'auto' },
+        ],
+      },
+      { onCancel }
+    );
+    projectType = picked;
+  }
+
+  const isElectron = projectType === 'electron';
+
+  let buildAndroid = true;
+  let buildIos = true;
+  let buildElectron = true;
+  let wantsSigning = false;
+
+  if (isElectron) {
+    console.log('\nElectron compila Linux, macOS y Windows en paralelo — no hace falta elegir.\n');
+  } else {
+    const { target } = await prompts(
+      {
+        type: 'select',
+        name: 'target',
+        message: '¿Qué deseas compilar?',
+        choices: [
+          { title: 'Android + iOS (ambas)', value: 'both' },
+          { title: 'Solo Android', value: 'android' },
+          { title: 'Solo iOS', value: 'ios' },
+        ],
+      },
+      { onCancel }
+    );
+    buildAndroid = target !== 'ios';
+    buildIos = target !== 'android';
+
+    const signingAnswer = await prompts(
+      {
+        type: 'confirm',
+        name: 'wantsSigning',
+        message: '¿Ya tenés listos los secrets de firma (keystore / certificado de Apple)?',
+        initial: false,
+      },
+      { onCancel }
+    );
+    wantsSigning = signingAnswer.wantsSigning;
+  }
+
+  const { wantsRelease } = await prompts(
+    {
+      type: 'confirm',
+      name: 'wantsRelease',
+      message: '¿Adjuntar los builds a un GitHub Release cuando pushees un tag (v1.2.3)?',
+      initial: false,
+    },
+    { onCancel }
+  );
+
+  const workflowPath = path.join(cwd, '.github', 'workflows', 'build.yml');
+  if (fs.existsSync(workflowPath)) {
+    const { overwrite } = await prompts(
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `Ya existe ${path.relative(cwd, workflowPath)}. ¿Sobrescribir?`,
+        initial: false,
+      },
+      { onCancel }
+    );
+    if (!overwrite) {
+      console.log('\nCancelado — no se modificó nada.\n');
+      return;
+    }
+  }
+
+  const yaml = buildWorkflowYaml({
+    projectType,
+    buildAndroid,
+    buildIos,
+    buildElectron,
+    createRelease: wantsRelease,
+  });
+
+  fs.mkdirSync(path.dirname(workflowPath), { recursive: true });
+  fs.writeFileSync(workflowPath, yaml);
+
+  console.log(`\n✔ Escribí ${path.relative(cwd, workflowPath)}\n`);
+
+  if (isElectron) {
+    console.log(
+      'Los builds de Electron salen sin firmar por ahora (la firma de macOS/Windows\n' +
+        'todavía no está soportada por la plataforma).\n'
+    );
+  } else if (wantsSigning) {
+    console.log('Agregá estos secrets en GitHub (Settings → Secrets and variables → Actions):\n');
+    if (buildAndroid) console.log(`  Android: ${androidSecrets().join(', ')}`);
+    if (buildIos) console.log(`  iOS:     ${iosSecrets().join(', ')}`);
+    console.log('\nDetalle paso a paso: https://github.com/shadownrx/code/blob/main/docs/SIGNING.md\n');
+  } else {
+    console.log(
+      'Por ahora va a compilar sin firmar (sirve para probar que compila y correr en\n' +
+        'simulador/emulador). Cuando quieras builds firmados, mirá docs/SIGNING.md.\n'
+    );
+  }
+
+  console.log('Siguiente paso: hacé commit y push — el primer build corre solo, gratis,');
+  console.log('sin necesitar Mac (ni Windows, si es Electron) en tu máquina.\n');
+}
+
+main();

package/lib.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const PROJECT_LABELS = {
+  flutter: 'Flutter',
+  'react-native': 'React Native',
+  pwa: 'PWA (Capacitor)',
+  electron: 'Electron',
+};
+
+/**
+ * Same detection rules as .github/actions/detect-project/action.yml,
+ * ported to Node so the CLI can guess before asking.
+ */
+export function detectProjectType(cwd) {
+  const pubspecPath = path.join(cwd, 'pubspec.yaml');
+  if (fs.existsSync(pubspecPath)) {
+    const content = fs.readFileSync(pubspecPath, 'utf8');
+    if (/^\s*flutter:/m.test(content)) return 'flutter';
+  }
+
+  if (
+    fs.existsSync(path.join(cwd, 'capacitor.config.ts')) ||
+    fs.existsSync(path.join(cwd, 'capacitor.config.json'))
+  ) {
+    return 'pwa';
+  }
+
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps && (deps['electron'] || deps['electron-builder'])) return 'electron';
+      if (deps && deps['react-native']) return 'react-native';
+    } catch {
+      // malformed package.json — fall through to "not detected"
+    }
+  }
+
+  return null;
+}
+
+export function androidSecrets() {
+  return ['ANDROID_KEYSTORE_BASE64', 'ANDROID_KEYSTORE_PASSWORD', 'ANDROID_KEY_ALIAS', 'ANDROID_KEY_PASSWORD'];
+}
+
+export function iosSecrets() {
+  return ['IOS_CERTIFICATE_BASE64', 'IOS_CERTIFICATE_PASSWORD', 'IOS_PROVISION_PROFILE_BASE64', 'IOS_TEAM_ID'];
+}
+
+/**
+ * Builds the literal contents of .github/workflows/build.yml.
+ * Kept as plain string templating (not a YAML library) so the output
+ * matches exactly what docs/USAGE.md shows and stays easy to diff by eye.
+ *
+ * For projectType 'electron', buildAndroid/buildIos are irrelevant (that
+ * job only runs for mobile project types) and buildElectron is emitted
+ * instead — and vice versa.
+ */
+export function buildWorkflowYaml({ projectType, buildAndroid, buildIos, buildElectron, createRelease }) {
+  const lines = [
+    'name: Build Mobile Apps',
+    '',
+    'on:',
+    '  push:',
+    '    branches: [main]',
+    '    tags: ["v*"]',
+    '  pull_request:',
+    '  workflow_dispatch:',
+    '',
+    'jobs:',
+    '  build:',
+  ];
+
+  if (createRelease) {
+    lines.push('    permissions:', '      contents: write');
+  }
+
+  lines.push('    uses: shadownrx/code/.github/workflows/build-mobile.yml@main', '    with:', `      project_type: ${projectType}`);
+
+  if (projectType === 'electron') {
+    lines.push(`      build_electron: ${buildElectron}`);
+  } else {
+    lines.push(`      build_android: ${buildAndroid}`, `      build_ios: ${buildIos}`);
+  }
+
+  if (createRelease) {
+    lines.push('      create_release: true');
+  }
+
+  lines.push('    secrets: inherit', '');
+
+  return lines.join('\n');
+}

package/mcp-server.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+// MCP server exposing shadownrx/code's build-mobile.yml setup as tools for
+// any MCP client (Cursor, Claude Code, Windsurf, etc.) — not Cursor-specific,
+// MCP is an open standard. See cli/README.md for how to point Cursor at this.
+import fs from 'node:fs';
+import path from 'node:path';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import {
+  PROJECT_LABELS,
+  androidSecrets,
+  buildWorkflowYaml,
+  detectProjectType,
+  iosSecrets,
+} from './lib.js';
+
+const server = new McpServer({ name: 'shadownrx-code', version: '1.0.0' });
+
+const PROJECT_TYPES = ['auto', 'flutter', 'react-native', 'pwa', 'electron'];
+
+function text(str) {
+  return { content: [{ type: 'text', text: str }] };
+}
+
+server.registerTool(
+  'detect_project_type',
+  {
+    title: 'Detect mobile/desktop project type',
+    description:
+      'Looks at a directory and reports whether it is a Flutter, React Native, PWA (Capacitor), or Electron ' +
+      'project, using the same rules as build-mobile.yml\'s auto-detection. Read-only — writes nothing.',
+    inputSchema: {
+      cwd: z.string().optional().describe('Directory to inspect. Defaults to the server process cwd.'),
+    },
+  },
+  async ({ cwd }) => {
+    const dir = cwd ? path.resolve(cwd) : process.cwd();
+    if (!fs.existsSync(dir)) {
+      return { ...text(`No existe el directorio: ${dir}`), isError: true };
+    }
+    const detected = detectProjectType(dir);
+    if (!detected) {
+      return text(
+        `No se detectó ningún tipo de proyecto conocido en ${dir}.\n` +
+          'Buscado: pubspec.yaml con flutter:, capacitor.config.ts/json, o package.json ' +
+          'con electron/electron-builder/react-native.'
+      );
+    }
+    return text(`Detectado: ${PROJECT_LABELS[detected]} (project_type: ${detected}) en ${dir}`);
+  }
+);
+
+server.registerTool(
+  'setup_mobile_ci',
+  {
+    title: 'Set up free Android/iOS/Electron CI',
+    description:
+      'Writes .github/workflows/build.yml wired to shadownrx/code\'s free reusable GitHub Actions workflow ' +
+      '(build-mobile.yml), which builds Android/iOS (no Mac needed) or Electron for Linux/macOS/Windows ' +
+      '(no Mac or Windows machine needed), depending on project_type. Detects the project type automatically ' +
+      'if not given. Refuses to overwrite an existing build.yml unless overwrite is true.',
+    inputSchema: {
+      cwd: z.string().optional().describe('Project root to write .github/workflows/build.yml into. Defaults to the server process cwd.'),
+      project_type: z.enum(PROJECT_TYPES).optional().describe('Defaults to auto-detecting from the project files.'),
+      build_android: z.boolean().optional().describe('Only relevant for flutter/react-native/pwa. Default true.'),
+      build_ios: z.boolean().optional().describe('Only relevant for flutter/react-native/pwa. Default true.'),
+      build_electron: z.boolean().optional().describe('Only relevant for project_type electron. Default true.'),
+      create_release: z.boolean().optional().describe('Attach build artifacts to a GitHub Release on tag pushes. Default false.'),
+      overwrite: z.boolean().optional().describe('Overwrite an existing .github/workflows/build.yml. Default false.'),
+    },
+  },
+  async ({ cwd, project_type, build_android, build_ios, build_electron, create_release, overwrite }) => {
+    const dir = cwd ? path.resolve(cwd) : process.cwd();
+    if (!fs.existsSync(dir)) {
+      return { ...text(`No existe el directorio: ${dir}`), isError: true };
+    }
+
+    let projectType = project_type;
+    if (!projectType || projectType === 'auto') {
+      const detected = detectProjectType(dir);
+      if (!detected) {
+        return {
+          ...text(
+            `No pude detectar el tipo de proyecto en ${dir}. Pasá project_type explícitamente ` +
+              `(${PROJECT_TYPES.filter((t) => t !== 'auto').join(', ')}).`
+          ),
+          isError: true,
+        };
+      }
+      projectType = detected;
+    }
+
+    const isElectron = projectType === 'electron';
+    const yaml = buildWorkflowYaml({
+      projectType,
+      buildAndroid: build_android ?? true,
+      buildIos: build_ios ?? true,
+      buildElectron: build_electron ?? true,
+      createRelease: create_release ?? false,
+    });
+
+    const workflowPath = path.join(dir, '.github', 'workflows', 'build.yml');
+    const relPath = path.relative(dir, workflowPath);
+    if (fs.existsSync(workflowPath) && !overwrite) {
+      return {
+        ...text(
+          `Ya existe ${relPath}. Llamá de nuevo con overwrite: true si querés reemplazarlo.\n\n` +
+            'Contenido propuesto:\n\n```yaml\n' + yaml + '\n```'
+        ),
+        isError: true,
+      };
+    }
+
+    fs.mkdirSync(path.dirname(workflowPath), { recursive: true });
+    fs.writeFileSync(workflowPath, yaml);
+
+    const notes = [`Escribí ${relPath} (project_type: ${projectType}).`];
+    if (isElectron) {
+      notes.push('Los builds de Electron salen sin firmar por ahora (firma de macOS/Windows no soportada todavía).');
+    } else {
+      notes.push(
+        'Sin firma por defecto. Para builds firmados agregá los secrets de GitHub descritos en docs/SIGNING.md:\n' +
+          `  Android: ${androidSecrets().join(', ')}\n` +
+          `  iOS:     ${iosSecrets().join(', ')}`
+      );
+    }
+    notes.push('Siguiente paso: commit + push. El build corre gratis en GitHub Actions.');
+
+    return text(notes.join('\n\n') + '\n\n```yaml\n' + yaml + '\n```');
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "shadownrx-code",
+  "version": "1.0.0",
+  "description": "Interactive CLI + MCP server for the shadownrx/code free Android/iOS/PWA/Electron build platform — writes .github/workflows/build.yml for your project, or exposes the same thing as tools for Cursor/Claude Code/any MCP client.",
+  "type": "module",
+  "bin": {
+    "shadownrx-code": "bin.js",
+    "shadownrx-code-mcp": "mcp-server.js"
+  },
+  "files": [
+    "bin.js",
+    "lib.js",
+    "mcp-server.js"
+  ],
+  "scripts": {
+    "start": "node bin.js",
+    "mcp": "node mcp-server.js",
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "prompts": "^2.4.2",
+    "zod": "^4.5.4"
+  }
+}