@take-out/scripts 0.0.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 vxrn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@take-out/scripts",
+  "version": "0.0.28",
+  "type": "module",
+  "main": "./src/index.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    "./helpers/*": {
+      "types": "./src/helpers/*.ts",
+      "default": "./src/helpers/*.ts"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@take-out/helpers": "0.0.28"
+  },
+  "devDependencies": {
+    "vxrn": "*"
+  }
+}

package/src/bootstrap.ts

@@ -0,0 +1,182 @@
+#!/usr/bin/env bun
+
+/**
+ * @description Bootstrap project dependencies and workspace packages
+ *
+ * This script runs automatically during `bun install` via the prepare lifecycle.
+ * It manages the .env file configuration with the following responsibilities:
+ *
+ * 1. Creates .env from .env.template if it doesn't exist
+ * 2. Maintains an auto-generated section in .env with package metadata
+ * 3. Currently syncs ZERO_VERSION from package.json dependencies
+ * 4. Preserves all user-defined environment variables
+ * 5. Creates backups before modifications for safety
+ *
+ * The auto-generated section is clearly marked and should not be edited manually.
+ * All operations are defensive and will not fail the install process.
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  renameSync,
+  unlinkSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { getZeroVersion } from '@take-out/scripts/helpers/zero-get-version'
+
+const ENV_PATH = join(process.cwd(), '.env')
+const ENV_TEMPLATE_PATH = join(process.cwd(), '.env.template')
+const ENV_BACKUP_PATH = join(process.cwd(), '.env.backup')
+const ENV_TEMP_PATH = join(process.cwd(), '.env.tmp')
+
+// auto-generated section markers
+const BEGIN_MARKER = '# ---- BEGIN AUTO-GENERATED (DO NOT EDIT) ----'
+const END_MARKER = '# ---- END AUTO-GENERATED ----'
+
+function createEnvFromTemplate(): boolean {
+  if (!existsSync(ENV_TEMPLATE_PATH)) {
+    console.info('No .env.template found, skipping .env creation')
+    return false
+  }
+
+  try {
+    copyFileSync(ENV_TEMPLATE_PATH, ENV_PATH)
+    console.info('Created .env from .env.template')
+    return true
+  } catch (error) {
+    console.error('Failed to create .env from .env.template:', error)
+    return false
+  }
+}
+
+function getAutoGeneratedContent(): string {
+  const zeroVersion = getZeroVersion()
+  if (!zeroVersion) {
+    console.warn('Could not determine Zero version')
+    return ''
+  }
+
+  // build the auto-generated content
+  const lines = [
+    BEGIN_MARKER,
+    `# Generated at: ${new Date().toISOString()}`,
+    `ZERO_VERSION=${zeroVersion}`,
+    END_MARKER,
+  ]
+
+  return lines.join('\n')
+}
+
+function updateEnvFile(): void {
+  // ensure .env exists
+  if (!existsSync(ENV_PATH)) {
+    const created = createEnvFromTemplate()
+    if (!created && !existsSync(ENV_PATH)) {
+      // create empty .env if no template exists
+      writeFileSync(ENV_PATH, '')
+      console.info('Created empty .env file')
+    }
+  }
+
+  try {
+    // create backup
+    if (existsSync(ENV_PATH)) {
+      copyFileSync(ENV_PATH, ENV_BACKUP_PATH)
+    }
+
+    // read current content
+    const currentContent = readFileSync(ENV_PATH, 'utf-8')
+
+    // find existing auto-generated section
+    const beginIndex = currentContent.indexOf(BEGIN_MARKER)
+    const endIndex = currentContent.indexOf(END_MARKER)
+
+    let newContent: string
+
+    if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+      // replace existing auto-generated section
+      const beforeSection = currentContent.substring(0, beginIndex).trimEnd()
+      const afterSection = currentContent
+        .substring(endIndex + END_MARKER.length)
+        .trimStart()
+
+      newContent = [beforeSection, getAutoGeneratedContent(), afterSection]
+        .filter(Boolean)
+        .join('\n\n')
+    } else if (beginIndex !== -1 || endIndex !== -1) {
+      // malformed markers - preserve content and append new section
+      console.warn('Found malformed auto-generated section, appending new section')
+      newContent = currentContent.trimEnd() + '\n\n' + getAutoGeneratedContent()
+    } else {
+      // no existing section - append to end
+      const trimmedContent = currentContent.trimEnd()
+      newContent = trimmedContent
+        ? trimmedContent + '\n\n' + getAutoGeneratedContent()
+        : getAutoGeneratedContent()
+    }
+
+    // write to temp file first (atomic operation)
+    writeFileSync(ENV_TEMP_PATH, newContent)
+
+    // validate temp file
+    const tempContent = readFileSync(ENV_TEMP_PATH, 'utf-8')
+    if (!tempContent.includes(BEGIN_MARKER) || !tempContent.includes(END_MARKER)) {
+      throw new Error('Generated content validation failed')
+    }
+
+    // atomic replace
+    renameSync(ENV_TEMP_PATH, ENV_PATH)
+
+    if (existsSync(ENV_BACKUP_PATH)) {
+      try {
+        unlinkSync(ENV_BACKUP_PATH)
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+
+    console.info('Updated .env auto-generated section')
+  } catch (error) {
+    console.error('Failed to update .env file:', error)
+
+    // attempt to restore backup
+    if (existsSync(ENV_BACKUP_PATH)) {
+      try {
+        copyFileSync(ENV_BACKUP_PATH, ENV_PATH)
+        console.info('Restored .env from backup')
+      } catch (restoreError) {
+        console.error('Failed to restore backup:', restoreError)
+      }
+    }
+
+    // clean up temp file
+    if (existsSync(ENV_TEMP_PATH)) {
+      try {
+        unlinkSync(ENV_TEMP_PATH)
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+
+    // don't fail the install process
+    process.exit(0)
+  }
+}
+
+// main execution
+// skip bootstrap in CI environments
+if (process.env.CI === 'true') {
+  console.info('Skipping bootstrap in CI environment')
+  process.exit(0)
+}
+
+try {
+  updateEnvFile()
+} catch (error) {
+  // catch any unexpected errors and exit gracefully
+  console.error('Bootstrap script error:', error)
+  process.exit(0)
+}

package/src/check-circular-deps.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+import { $ } from 'bun'
+import { globSync } from 'glob'
+import { basename } from 'node:path'
+
+const projectRoot = process.cwd()
+
+// parse --ignore flag
+const args = process.argv.slice(2)
+const ignoreIndex = args.indexOf('--ignore')
+const ignoredFiles: string[] = []
+
+if (ignoreIndex !== -1 && args[ignoreIndex + 1]) {
+  // split comma-separated files
+  const ignoreArg = args[ignoreIndex + 1]
+  if (ignoreArg) {
+    const ignoreList = ignoreArg.split(',')
+    ignoredFiles.push(...ignoreList.map((f) => f.trim()))
+  }
+}
+
+// glob all tsx files in app directory
+const appFiles = globSync('app/**/*.tsx', {
+  cwd: projectRoot,
+  absolute: true,
+})
+
+// glob all tsx files in src directory
+const srcFiles = globSync('src/**/*.tsx', {
+  cwd: projectRoot,
+  absolute: true,
+})
+
+// combine all files
+const allFiles = [...appFiles, ...srcFiles]
+
+if (allFiles.length === 0) {
+  console.error('No tsx files found')
+  process.exit(1)
+}
+
+// build the command with all -r flags
+const commandArgs = [
+  'bunx',
+  '@glideapps/ts-helper',
+  '-c', // check circular dependencies
+  '-p',
+  projectRoot,
+  ...allFiles.flatMap((file) => ['-r', file]),
+]
+
+console.info(`Checking circular dependencies for ${allFiles.length} files...`)
+
+try {
+  // run the command and capture output
+  await $`${commandArgs}`.quiet()
+  console.info('✅ No circular dependencies found')
+} catch (error: any) {
+  // parse the output to check for cycles
+  const output = error.stderr?.toString() || error.stdout?.toString() || ''
+
+  // parse cycle arrays from output
+  const cycleRegex = /\[([^\]]+)\]/g
+  const cycles: string[][] = []
+  let match
+
+  while ((match = cycleRegex.exec(output)) !== null) {
+    // parse the cycle array
+    const cycleStr = match[1]
+    if (cycleStr) {
+      const files = cycleStr.split(',').map((f) => f.trim().replace(/"/g, ''))
+      cycles.push(files)
+    }
+  }
+
+  // filter out cycles that contain ignored files
+  const remainingCycles = cycles.filter((cycle) => {
+    const containsIgnored = cycle.some((file) =>
+      ignoredFiles.some((ignored) => basename(file) === ignored || file.includes(ignored))
+    )
+    return !containsIgnored
+  })
+
+  if (remainingCycles.length > 0) {
+    // reconstruct output with filtered cycles
+    console.info(
+      output
+        .split('\n')
+        .filter((line: string) => !line.startsWith('['))
+        .join('\n')
+    )
+    console.info(`Found ${remainingCycles.length} dependency cycles`)
+    remainingCycles.forEach((cycle) => {
+      console.info(JSON.stringify(cycle))
+    })
+    console.error('❌ Circular dependencies detected')
+    process.exit(1)
+  } else if (cycles.length > 0) {
+    // all cycles were ignored
+    console.info(
+      `✅ Found ${cycles.length} circular dependencies but all contain ignored files`
+    )
+    if (ignoredFiles.length > 0) {
+      console.info(`   Ignored files: ${ignoredFiles.join(', ')}`)
+    }
+  } else {
+    // no cycles found, but command failed for another reason
+    console.error(output)
+    console.error('❌ Error running circular dependency check')
+    process.exit(1)
+  }
+}

package/src/clean.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env bun
+
+/**
+ * @description Clean build artifacts and temporary files
+ */
+
+import { execSync } from 'node:child_process'
+
+try {
+  execSync('rm -rf dist types .tamagui .vite node_modules/.cache', { stdio: 'inherit' })
+  console.info('Cleanup complete!')
+} catch (error) {
+  console.error('Error cleaning up')
+  throw error
+}

package/src/dev-tunnel-if-exist.ts

@@ -0,0 +1,166 @@
+#!/usr/bin/env bun
+
+import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const TUNNEL_CONFIG_DIR = join(homedir(), '.onechat-tunnel')
+const TUNNEL_ID_FILE = join(TUNNEL_CONFIG_DIR, 'tunnel-id.txt')
+const TUNNEL_CONFIG_FILE = join(TUNNEL_CONFIG_DIR, 'config.yml')
+
+// check internet connectivity first
+async function checkInternetConnection(): Promise<boolean> {
+  return new Promise((resolve) => {
+    // try to ping cloudflare dns
+    const pingProcess = spawn('ping', ['-c', '1', '-W', '2', '1.1.1.1'], {
+      stdio: 'pipe',
+    })
+
+    pingProcess.on('error', () => {
+      resolve(false)
+    })
+
+    pingProcess.on('exit', (code) => {
+      resolve(code === 0)
+    })
+  })
+}
+
+// check connectivity before proceeding
+const isOnline = await checkInternetConnection()
+if (!isOnline) {
+  console.info('📵 Offline - skipping tunnel setup')
+  // Keep process alive for watch mode
+  await new Promise(() => {})
+}
+
+// ensure config dir exists
+if (!existsSync(TUNNEL_CONFIG_DIR)) {
+  mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
+}
+
+// check if cloudflared is authenticated
+const certPath = join(homedir(), '.cloudflared', 'cert.pem')
+const hasCloudflaredAuth = existsSync(certPath)
+
+if (!hasCloudflaredAuth) {
+  console.info('☁️  Tunnel not set up. Run "bun dev:tunnel" to enable.')
+  // Keep process alive for watch mode
+  await new Promise(() => {})
+}
+
+// check if we have a tunnel id
+const hasTunnelId = existsSync(TUNNEL_ID_FILE)
+if (!hasTunnelId) {
+  console.info('☁️  No tunnel created. Run "bun dev:tunnel" once to set up.')
+  // Keep process alive for watch mode
+  await new Promise(() => {})
+}
+
+// check if cloudflared is installed
+const checkProcess = spawn('which', ['cloudflared'], {
+  shell: true,
+  stdio: 'pipe',
+})
+
+checkProcess.on('error', () => {
+  console.warn('⚠️  cloudflared not found - skipping tunnel setup')
+  // Keep process alive for watch mode
+  new Promise(() => {})
+})
+
+checkProcess.on('exit', async (code) => {
+  if (code === 0) {
+    const tunnelId = readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
+    const tunnelName = 'onechat-dev-n8' // your tunnel name
+    console.info(`🚇 Starting tunnel ${tunnelId}...`)
+
+    // The stable URL format for your domain
+    const tunnelDomain = `${tunnelName}.start.chat`
+
+    // Create config file with ingress rules
+    const tunnelConfig = `
+tunnel: ${tunnelId}
+credentials-file: ${join(homedir(), '.cloudflared', `${tunnelId}.json`)}
+
+ingress:
+  - hostname: ${tunnelDomain}
+    service: http://localhost:8081
+  - service: http_status:404
+`
+    writeFileSync(TUNNEL_CONFIG_FILE, tunnelConfig)
+
+    // Set up DNS route if needed (this is idempotent, safe to run multiple times)
+    const routeProcess = spawn(
+      'cloudflared',
+      ['tunnel', 'route', 'dns', tunnelId, tunnelDomain],
+      {
+        stdio: 'pipe',
+        shell: true,
+      }
+    )
+
+    await new Promise((resolve) => {
+      routeProcess.on('exit', resolve)
+    })
+
+    const tunnelUrl = `https://${tunnelDomain}`
+    const tunnelUrlFile = join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt')
+    writeFileSync(tunnelUrlFile, tunnelUrl)
+    console.info(`🌐 Tunnel URL: ${tunnelUrl}`)
+
+    // Run tunnel with config file
+    const tunnelProcess = spawn(
+      'cloudflared',
+      ['tunnel', '--config', TUNNEL_CONFIG_FILE, 'run'],
+      {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: true,
+      }
+    )
+
+    // Track if we've shown the connection message
+    let hasShownConnected = false
+
+    // Process stdout to filter logs
+    tunnelProcess.stdout?.on('data', (data) => {
+      const output = data.toString()
+
+      // Only show first successful connection
+      if (!hasShownConnected && output.includes('Registered tunnel connection')) {
+        console.info('✅ Tunnel connected')
+        hasShownConnected = true
+      }
+    })
+
+    // Process stderr (where cloudflared logs go)
+    tunnelProcess.stderr?.on('data', (data) => {
+      const output = data.toString()
+
+      // Only show first successful connection
+      if (!hasShownConnected && output.includes('Registered tunnel connection')) {
+        console.info('✅ Tunnel connected')
+        hasShownConnected = true
+      }
+    })
+
+    // handle process termination
+    process.on('SIGINT', () => {
+      tunnelProcess.kill()
+      process.exit(0)
+    })
+
+    tunnelProcess.on('exit', (code) => {
+      if (code !== 0) {
+        console.warn(`⚠️  Tunnel process exited with code ${code}`)
+      }
+      // Keep process alive for watch mode
+      new Promise(() => {})
+    })
+  } else {
+    console.warn('⚠️  cloudflared not found - skipping tunnel setup')
+    // Keep process alive for watch mode
+    await new Promise(() => {})
+  }
+})

package/src/dev-tunnel.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env bun
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { handleProcessExit } from './helpers/handleProcessExit'
+import { run } from './helpers/run'
+
+handleProcessExit()
+
+const TUNNEL_CONFIG_DIR = join(homedir(), '.onechat-tunnel')
+const TUNNEL_ID_FILE = join(TUNNEL_CONFIG_DIR, 'tunnel-id.txt')
+
+async function ensureCloudflared(): Promise<boolean> {
+  try {
+    // check if cloudflared is installed
+    await run('cloudflared --version', { silent: true })
+    return true
+  } catch {
+    // install cloudflared using npm
+    try {
+      await run('npm install -g cloudflared')
+      return true
+    } catch (error) {
+      console.error('Error installing cloudflared:', error)
+      return false
+    }
+  }
+}
+
+async function ensureAuthenticated(): Promise<boolean> {
+  // check if we have credentials
+  const certPath = join(homedir(), '.cloudflared', 'cert.pem')
+  if (existsSync(certPath)) {
+    return true
+  }
+
+  try {
+    await run('cloudflared tunnel login')
+    return true
+  } catch {
+    console.error('\n❌ Authentication failed')
+    return false
+  }
+}
+
+async function getOrCreateTunnel(): Promise<string | null> {
+  // create config directory if it doesn't exist
+  if (!existsSync(TUNNEL_CONFIG_DIR)) {
+    mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
+  }
+
+  // check if we have a saved tunnel ID
+  if (existsSync(TUNNEL_ID_FILE)) {
+    const tunnelId = readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
+    return tunnelId
+  }
+
+  // create a new tunnel with a stable name
+  const tunnelName = `onechat-dev-${process.env.USER || 'tunnel'}`
+
+  try {
+    const { stdout, stderr } = await run(`cloudflared tunnel create ${tunnelName}`, {
+      captureOutput: true,
+    })
+    const output = stdout + stderr
+
+    // extract tunnel ID from output - try multiple patterns
+    const match1 = output.match(/Created tunnel .+ with id ([a-f0-9-]+)/i)
+    const match2 = output.match(/Tunnel ([a-f0-9-]+) created/i)
+    const match3 = output.match(
+      /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i
+    )
+
+    const tunnelId = match1?.[1] || match2?.[1] || match3?.[1]
+
+    if (tunnelId) {
+      writeFileSync(TUNNEL_ID_FILE, tunnelId)
+      return tunnelId
+    }
+
+    console.error('Failed to extract tunnel ID from output')
+    console.error('Output was:', output)
+    return null
+  } catch (error: any) {
+    // check if tunnel already exists
+    if (error.message?.includes('already exists')) {
+      try {
+        const { stdout } = await run(
+          `cloudflared tunnel list --name ${tunnelName} --output json`,
+          { captureOutput: true }
+        )
+        const tunnels = JSON.parse(stdout)
+        if (tunnels.length > 0) {
+          const tunnelId = tunnels[0].id
+          writeFileSync(TUNNEL_ID_FILE, tunnelId)
+          return tunnelId
+        }
+      } catch (e) {
+        console.error('Failed to parse tunnel list:', e)
+      }
+    } else {
+      console.error('Failed to create tunnel:', error)
+    }
+    return null
+  }
+}
+
+async function runTunnel(port: number = 8081) {
+  // ensure cloudflared is installed
+  const isInstalled = await ensureCloudflared()
+  if (!isInstalled) {
+    console.error('Failed to install cloudflared')
+    process.exit(1)
+  }
+
+  // ensure authenticated
+  const isAuthenticated = await ensureAuthenticated()
+  if (!isAuthenticated) {
+    console.error('Failed to authenticate with Cloudflare')
+    process.exit(1)
+  }
+
+  // get or create tunnel
+  const tunnelId = await getOrCreateTunnel()
+  if (!tunnelId) {
+    console.error('Failed to get or create tunnel')
+    process.exit(1)
+  }
+
+  // save the expected URL immediately so it's available right away
+  const expectedUrl = `https://${tunnelId}.cfargotunnel.com`
+  writeFileSync(join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'), expectedUrl)
+  console.info(`\n🌐 Tunnel URL: ${expectedUrl}`)
+
+  // get the public URL in the background
+  setTimeout(async () => {
+    try {
+      const { stdout } = await run(`cloudflared tunnel info ${tunnelId} --output json`, {
+        captureOutput: true,
+        silent: true,
+      })
+
+      try {
+        const info = JSON.parse(stdout)
+        const hostname = info.hostname || `${tunnelId}.cfargotunnel.com`
+        writeFileSync(join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'), `https://${hostname}`)
+      } catch (e) {
+        // use fallback URL already saved
+      }
+    } catch (e) {
+      // use fallback URL already saved
+    }
+  }, 3000)
+
+  // run tunnel in detached mode so it keeps running and gets managed by handleProcessExit
+  await run(`cloudflared tunnel run --url http://localhost:${port} ${tunnelId}`, {
+    detached: false,
+  })
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2)
+let port = 8081
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--port' && args[i + 1]) {
+    const portArg = args[i + 1]
+    if (portArg) {
+      const parsedPort = parseInt(portArg, 10)
+      if (!Number.isNaN(parsedPort)) {
+        port = parsedPort
+      }
+    }
+  }
+}
+
+runTunnel(port)