offbyt 1.0.0

package/deploy/flyio.js

@@ -0,0 +1,51 @@
+import { deployWithCommand, isCommandAvailable, runCommandCapture } from './utils.js';
+
+async function checkFlyLogin(command) {
+  try {
+    const result = await runCommandCapture({
+      command,
+      args: ['auth', 'whoami'],
+      cwd: process.cwd(),
+      streamOutput: false
+    });
+    return !result.stdout.toLowerCase().includes('not logged in');
+  } catch {
+    return false;
+  }
+}
+
+async function resolveFlyCommand() {
+  if (await isCommandAvailable('flyctl')) {
+    return 'flyctl';
+  }
+
+  if (await isCommandAvailable('fly')) {
+    return 'fly';
+  }
+
+  return 'flyctl';
+}
+
+const FLY_INSTALL_HINT = [
+  'Install Fly CLI manually, then re-run deploy.',
+  'Windows options:',
+  '  winget install --id Fly-io.flyctl -e',
+  '  or choco install flyctl',
+  '  or scoop install flyctl'
+].join('\n');
+
+export async function deployToFlyIO(backendPath) {
+  const flyCommand = await resolveFlyCommand();
+
+  return deployWithCommand({
+    providerName: 'Fly.io',
+    command: flyCommand,
+    installHint: FLY_INSTALL_HINT,
+    args: ['deploy', '--remote-only'],
+    cwd: backendPath,
+    urlHints: ['fly.dev'],
+    loginCheck: () => checkFlyLogin(flyCommand),
+    loginCommand: { command: flyCommand, args: ['auth', 'login'] },
+    successLabel: 'Backend deployed on Fly.io'
+  });
+}

package/deploy/index.js

@@ -0,0 +1,322 @@
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { deployToVercel } from './vercel.js';
+import { deployToNetlify } from './netlify.js';
+import { deployToCloudflare } from './cloudflare.js';
+import { deployToRailway } from './railway.js';
+import { deployToRender } from './render.js';
+import { deployToCloudflareWorker } from './cloudflareWorker.js';
+import { autoConnectDeployment } from './connect.js';
+import { detectBackendPath, detectFrontendPath, normalizeProviderKey } from './utils.js';
+
+const FRONTEND_PROVIDER_CHOICES = [
+  { name: 'Vercel', value: 'vercel' },
+  { name: 'Netlify', value: 'netlify' },
+  { name: 'Cloudflare Pages', value: 'cloudflare' },
+  { name: 'Skip frontend', value: 'skip' }
+];
+
+const BACKEND_PROVIDER_CHOICES = [
+  { name: 'Railway', value: 'railway' },
+  { name: 'Render', value: 'render' },
+  { name: 'Cloudflare Pages (Free)', value: 'cloudflare' },
+  { name: 'Skip backend', value: 'skip' }
+];
+
+const FRONTEND_DEPLOYERS = {
+  vercel: deployToVercel,
+  netlify: deployToNetlify,
+  cloudflare: deployToCloudflare,
+  skip: null
+};
+
+const BACKEND_DEPLOYERS = {
+  railway: deployToRailway,
+  render: deployToRender,
+  cloudflare: deployToCloudflareWorker,
+  skip: null
+};
+
+const FRONTEND_ALIASES = {
+  vercel: 'vercel',
+  netlify: 'netlify',
+  cloudflare: 'cloudflare',
+  cloudflarepages: 'cloudflare',
+  skip: 'skip',
+  skipfrontend: 'skip'
+};
+
+const BACKEND_ALIASES = {
+  railway: 'railway',
+  render: 'render',
+  cloudflare: 'cloudflare',
+  cloudflareworker: 'cloudflare',
+  cloudflareworkers: 'cloudflare',
+  worker: 'cloudflare',
+  workers: 'cloudflare',
+  skip: 'skip',
+  skipbackend: 'skip'
+};
+
+export async function runDeploymentFlow(projectPath, options = {}) {
+  const resolvedProjectPath = path.resolve(projectPath || process.cwd());
+
+  console.log(chalk.cyan('\noffbyt Deployment\n'));
+
+  const selection = await resolveProviders(options);
+  const frontendPath = detectFrontendPath(resolvedProjectPath);
+  const backendPath = detectBackendPath(resolvedProjectPath);
+
+  const result = {
+    frontendProvider: selection.frontend,
+    backendProvider: selection.backend,
+    frontendUrl: null,
+    backendUrl: null,
+    connected: null
+  };
+
+  if (selection.frontend && selection.frontend !== 'skip') {
+    const deployFrontend = FRONTEND_DEPLOYERS[selection.frontend];
+    if (!deployFrontend) {
+      throw new Error(`Unsupported frontend provider: ${selection.frontend}`);
+    }
+
+    const frontendDeployResult = await deployFrontend(frontendPath, selection.frontendOptions || {});
+    result.frontendUrl = frontendDeployResult.url;
+  }
+
+  if (selection.backend && selection.backend !== 'skip') {
+    const deployBackend = BACKEND_DEPLOYERS[selection.backend];
+    if (!deployBackend) {
+      throw new Error(`Unsupported backend provider: ${selection.backend}`);
+    }
+
+    const backendDeployResult = await deployBackend(backendPath, selection.backendOptions || {});
+    result.backendUrl = backendDeployResult.url;
+  }
+
+  if (result.backendUrl && selection.frontend && selection.frontend !== 'skip') {
+    result.connected = autoConnectDeployment({
+      projectPath: resolvedProjectPath,
+      frontendPath,
+      backendUrl: result.backendUrl
+    });
+  }
+
+  printSummary(result);
+}
+
+async function resolveProviders(options) {
+  const normalizedFrontend = normalizeFrontendProvider(options.frontend);
+  const normalizedBackend = normalizeBackendProvider(options.backend);
+  const fallbackBackend = normalizedBackend || 'railway';
+
+  if (options.full) {
+    return {
+      frontend: normalizedFrontend || 'vercel',
+      backend: fallbackBackend,
+      frontendOptions: await resolveFrontendOptions(normalizedFrontend || 'vercel'),
+      backendOptions: await resolveBackendOptions(fallbackBackend, options, { interactive: false })
+    };
+  }
+
+  const answers = [];
+
+  if (!normalizedFrontend) {
+    answers.push(
+      await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'frontend',
+          message: 'Select frontend hosting',
+          choices: FRONTEND_PROVIDER_CHOICES
+        }
+      ])
+    );
+  }
+
+  if (!normalizedBackend) {
+    answers.push(
+      await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'backend',
+          message: 'Select backend hosting',
+          choices: BACKEND_PROVIDER_CHOICES
+        }
+      ])
+    );
+  }
+
+  const frontend = normalizedFrontend || answers.find((entry) => entry.frontend)?.frontend;
+  const backend = normalizedBackend || answers.find((entry) => entry.backend)?.backend;
+
+  return {
+    frontend,
+    backend,
+    frontendOptions: await resolveFrontendOptions(frontend),
+    backendOptions: await resolveBackendOptions(backend, options, { interactive: true })
+  };
+}
+
+function normalizeFrontendProvider(value) {
+  if (!value) return null;
+  const normalized = normalizeProviderKey(value);
+  const provider = FRONTEND_ALIASES[normalized];
+
+  if (!provider) {
+    throw new Error(`Invalid frontend provider: ${value}. Use vercel | netlify | cloudflare`);
+  }
+
+  return provider;
+}
+
+function normalizeBackendProvider(value) {
+  if (!value) return null;
+  const normalized = normalizeProviderKey(value);
+  const provider = BACKEND_ALIASES[normalized];
+
+  if (!provider) {
+    throw new Error(`Invalid backend provider: ${value}. Use railway | render | cloudflare | skip`);
+  }
+
+  return provider;
+}
+
+async function resolveFrontendOptions(frontendProvider) {
+  if (frontendProvider !== 'cloudflare') {
+    return {};
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'buildDir',
+      message: 'Build output directory for Cloudflare Pages',
+      default: 'dist'
+    }
+  ]);
+
+  return {
+    buildDir: answers.buildDir
+  };
+}
+
+function buildDefaultRailwayProjectName() {
+  const stamp = new Date()
+    .toISOString()
+    .replace(/[-:TZ]/g, '')
+    .slice(0, 12);
+
+  return `offbyt-${stamp}`;
+}
+
+async function resolveBackendOptions(backendProvider, options = {}, { interactive = false } = {}) {
+  if (!backendProvider || backendProvider === 'skip') {
+    return {};
+  }
+
+  const cliServiceId = String(options.backendServiceId || process.env.RENDER_SERVICE_ID || '').trim();
+
+  if (backendProvider === 'render') {
+    if (cliServiceId) {
+      return { serviceId: cliServiceId };
+    }
+
+    if (!interactive) {
+      return {};
+    }
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'serviceId',
+        message: 'Render service ID (required)',
+        validate: (value) => String(value || '').trim().length > 0 || 'Service ID is required',
+        filter: (value) => String(value || '').trim()
+      }
+    ]);
+
+    return { serviceId: answers.serviceId };
+  }
+
+  if (backendProvider === 'cloudflare') {
+    const cliProjectName = String(options.backendProjectName || process.env.CLOUDFLARE_PAGES_PROJECT || '').trim();
+    return cliProjectName ? { projectName: cliProjectName } : {};
+  }
+
+  if (backendProvider !== 'railway') {
+    return {};
+  }
+
+  const cliProjectName = String(options.backendProjectName || '').trim();
+  const cliServiceName = String(options.backendServiceName || '').trim();
+  if (cliProjectName) {
+    return {
+      projectName: cliProjectName,
+      ...(cliServiceName ? { serviceName: cliServiceName } : {})
+    };
+  }
+
+  if (!interactive) {
+    return {
+      projectName: buildDefaultRailwayProjectName(),
+      ...(cliServiceName ? { serviceName: cliServiceName } : {})
+    };
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Railway project name (auto-created if missing)',
+      default: buildDefaultRailwayProjectName(),
+      filter: (value) => String(value || '').trim()
+    },
+    {
+      type: 'input',
+      name: 'serviceName',
+      message: 'Railway service name (optional, leave blank for auto)',
+      default: cliServiceName,
+      filter: (value) => String(value || '').trim()
+    }
+  ]);
+
+  return {
+    projectName: answers.projectName || buildDefaultRailwayProjectName(),
+    ...(answers.serviceName ? { serviceName: answers.serviceName } : {})
+  };
+}
+
+function printSummary(result) {
+  console.log(chalk.green('\nDeployment complete\n'));
+
+  if (result.frontendUrl) {
+    console.log(chalk.green('✔ Frontend deployed ->'), chalk.white(result.frontendUrl));
+  } else {
+    console.log(chalk.yellow('• Frontend deployment skipped'));
+  }
+
+  if (result.backendUrl) {
+    console.log(chalk.green('✔ Backend deployed ->'), chalk.white(result.backendUrl));
+  } else {
+    console.log(chalk.yellow('• Backend deployment skipped'));
+  }
+
+  if (result.connected) {
+    console.log(chalk.green('\n✔ Frontend connected with backend')); 
+    console.log(chalk.gray(`  Updated source files: ${result.connected.updatedFileCount}`));
+    console.log(chalk.gray(`  Updated env files: ${result.connected.envFilesUpdated.length}`));
+  }
+
+  console.log(chalk.cyan('\nApp live:'));
+  if (result.frontendUrl) {
+    console.log(chalk.white(`Frontend -> ${result.frontendUrl}`));
+  }
+  if (result.backendUrl) {
+    console.log(chalk.white(`Backend  -> ${result.backendUrl}`));
+  }
+  console.log('');
+}
+

package/deploy/netlify.js

@@ -0,0 +1,29 @@
+import { deployWithCommand, runCommandCapture } from './utils.js';
+
+async function checkNetlifyLogin() {
+  try {
+    const result = await runCommandCapture({
+      command: 'netlify',
+      args: ['status'],
+      cwd: process.cwd(),
+      streamOutput: false
+    });
+    return result.stdout.toLowerCase().includes('logged in');
+  } catch {
+    return false;
+  }
+}
+
+export async function deployToNetlify(frontendPath) {
+  return deployWithCommand({
+    providerName: 'Netlify',
+    command: 'netlify',
+    packageName: 'netlify-cli',
+    args: ['deploy', '--prod'],
+    cwd: frontendPath,
+    urlHints: ['netlify.app'],
+    loginCheck: checkNetlifyLogin,
+    loginCommand: { command: 'netlify', args: ['login'] },
+    successLabel: 'Frontend deployed on Netlify'
+  });
+}

package/deploy/railway.js

@@ -0,0 +1,215 @@
+import { deployWithCommand, runCommandCapture } from './utils.js';
+
+function normalize(value = '') {
+  return String(value).trim().toLowerCase();
+}
+
+async function checkRailwayLogin() {
+  try {
+    const result = await runCommandCapture({
+      command: 'railway',
+      args: ['whoami'],
+      cwd: process.cwd(),
+      streamOutput: false
+    });
+    return result.stdout.trim().length > 0 && !result.stderr.toLowerCase().includes('not logged in');
+  } catch {
+    return false;
+  }
+}
+
+function buildDefaultRailwayProjectName() {
+  const stamp = new Date()
+    .toISOString()
+    .replace(/[-:TZ]/g, '')
+    .slice(0, 12);
+
+  return `offbyt-${stamp}`;
+}
+
+async function isRailwayProjectLinked(backendPath) {
+  try {
+    await runCommandCapture({
+      command: 'railway',
+      args: ['status'],
+      cwd: backendPath,
+      streamOutput: false
+    });
+    return true;
+  } catch (error) {
+    const message = String(error.message || '').toLowerCase();
+    if (message.includes('no linked project found')) {
+      return false;
+    }
+
+    // If status check itself fails for other reasons, treat as not linked and let init/link handle it.
+    return false;
+  }
+}
+
+async function ensureRailwayProjectLinked(backendPath, options = {}) {
+  const hasLinkedProject = await isRailwayProjectLinked(backendPath);
+  const requestedProject = String(options.projectName || '').trim();
+
+  if (hasLinkedProject && !requestedProject) {
+    return;
+  }
+
+  if (requestedProject) {
+    try {
+      await runCommandCapture({
+        command: 'railway',
+        args: ['link', '--project', requestedProject],
+        cwd: backendPath,
+        streamOutput: true
+      });
+      return;
+    } catch {
+      // Fall through to create the requested project when link fails.
+    }
+  }
+
+  if (hasLinkedProject && !requestedProject && !options.forceRelink) {
+    return;
+  }
+
+  const projectName = requestedProject || buildDefaultRailwayProjectName();
+  await runCommandCapture({
+    command: 'railway',
+    args: ['init', '-n', projectName],
+    cwd: backendPath,
+    streamOutput: true
+  });
+}
+
+function extractFirstJsonObject(raw = '') {
+  const text = String(raw || '').trim();
+  const first = text.indexOf('{');
+  const last = text.lastIndexOf('}');
+
+  if (first === -1 || last === -1 || last <= first) {
+    return null;
+  }
+
+  return text.slice(first, last + 1);
+}
+
+async function getRailwayStatus(backendPath) {
+  try {
+    const result = await runCommandCapture({
+      command: 'railway',
+      args: ['status', '--json'],
+      cwd: backendPath,
+      streamOutput: false
+    });
+
+    const jsonPayload = extractFirstJsonObject(result.stdout);
+    if (!jsonPayload) {
+      return null;
+    }
+
+    return JSON.parse(jsonPayload);
+  } catch {
+    return null;
+  }
+}
+
+function resolveRailwayServiceName(status, options = {}) {
+  const explicitServiceName = String(options.serviceName || '').trim();
+  if (explicitServiceName) {
+    return explicitServiceName;
+  }
+
+  const serviceEdges = status?.services?.edges || [];
+  const serviceNames = serviceEdges
+    .map((edge) => edge?.node?.name)
+    .filter(Boolean);
+
+  if (serviceNames.length === 0) {
+    return null;
+  }
+
+  const requestedProjectName = String(options.projectName || '').trim();
+  if (requestedProjectName) {
+    const matched = serviceNames.find((name) => normalize(name) === normalize(requestedProjectName));
+    if (matched) {
+      return matched;
+    }
+  }
+
+  // Use first service as fallback to avoid "multiple services" ambiguity.
+  return serviceNames[0];
+}
+
+function resolveRailwayDomainFromStatus(status) {
+  const envEdges = status?.environments?.edges || [];
+  for (const envEdge of envEdges) {
+    const serviceInstances = envEdge?.node?.serviceInstances?.edges || [];
+    for (const serviceEdge of serviceInstances) {
+      const domains = serviceEdge?.node?.domains?.serviceDomains || [];
+      const candidate = domains.find((item) => item?.domain)?.domain;
+      if (candidate) {
+        return `https://${candidate}`;
+      }
+    }
+  }
+
+  return null;
+}
+
+async function getRailwayPublicDomain(backendPath) {
+  const status = await getRailwayStatus(backendPath);
+  const domainFromStatus = resolveRailwayDomainFromStatus(status);
+  if (domainFromStatus) {
+    return domainFromStatus;
+  }
+
+  try {
+    const result = await runCommandCapture({
+      command: 'railway',
+      args: ['domain'],
+      cwd: backendPath,
+      streamOutput: false
+    });
+
+    const combinedOutput = `${result.stdout}\n${result.stderr}`;
+    const match = combinedOutput.match(/https?:\/\/[^\s"'`<>]+/i);
+    return match ? match[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function deployToRailway(backendPath, options = {}) {
+  let serviceName = String(options.serviceName || '').trim();
+
+  const preflight = async () => {
+    await ensureRailwayProjectLinked(backendPath, options);
+
+    const status = await getRailwayStatus(backendPath);
+    if (!serviceName) {
+      serviceName = resolveRailwayServiceName(status, options);
+    }
+  };
+
+  return deployWithCommand({
+    providerName: 'Railway',
+    command: 'railway',
+    packageName: '@railway/cli',
+    args: () => {
+      const deployArgs = ['up'];
+      if (serviceName) {
+        deployArgs.push('--service', serviceName);
+      }
+      return deployArgs;
+    },
+    cwd: backendPath,
+    urlHints: ['up.railway.app', 'railway.app'],
+    loginCheck: checkRailwayLogin,
+    loginCommand: { command: 'railway', args: ['login', '--browserless'] },
+    preflight,
+    postDeploy: async () => getRailwayPublicDomain(backendPath),
+    successLabel: 'Backend deployed on Railway'
+  });
+}
+