@phenx-inc/ctlsurf 0.1.0

package/bin/ctlsurf-worker.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+/**
+ * ctlsurf launcher
+ *
+ * Subcommands:
+ *   ctlsurf update     — pull latest and rebuild
+ *   ctlsurf doctor     — check all dependencies
+ *   ctlsurf version    — print version
+ *
+ * Modes (auto-detected or forced):
+ *   ctlsurf --terminal — terminal TUI mode
+ *   ctlsurf --desktop  — Electron GUI mode
+ */
+
+const { execFileSync, execSync } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+const ROOT = path.resolve(__dirname, '..')
+const args = process.argv.slice(2)
+const subcommand = args[0]
+
+// ─── Subcommands ──────────────────────────────────
+
+if (subcommand === 'version' || args.includes('--version') || args.includes('-v')) {
+  try {
+    const pkg = require(path.join(ROOT, 'package.json'))
+    console.log(`ctlsurf v${pkg.version}`)
+  } catch {
+    console.log('ctlsurf (unknown version)')
+  }
+  process.exit(0)
+}
+
+if (subcommand === 'update') {
+  const G = '\x1b[32m'
+  const Y = '\x1b[33m'
+  const B = '\x1b[34m'
+  const D = '\x1b[90m'
+  const R = '\x1b[0m'
+
+  console.log(`\n${B}  ctlsurf update${R}\n`)
+
+  try {
+    console.log(`${D}Updating via npm...${R}`)
+    execSync('npm update -g @phenx-inc/ctlsurf', { stdio: 'inherit' })
+
+    // Re-read version after update
+    let ver = '?'
+    try { ver = require(path.join(ROOT, 'package.json')).version } catch {}
+    console.log(`\n${G}✓${R} ctlsurf v${ver}\n`)
+  } catch (err) {
+    console.error(`\n${Y}!${R} Update failed: ${err.message}\n`)
+    process.exit(1)
+  }
+  process.exit(0)
+}
+
+if (subcommand === 'doctor') {
+  const G = '\x1b[32m'
+  const Y = '\x1b[33m'
+  const R = '\x1b[0m'
+  const D = '\x1b[90m'
+  const B = '\x1b[34m'
+
+  console.log(`\n${B}  ctlsurf doctor${R}\n`)
+
+  function check(name, cmd, required, fix) {
+    try {
+      const out = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+      const ver = out.split('\n')[0]
+      console.log(`  ${G}✓${R} ${name} ${D}${ver}${R}`)
+      return true
+    } catch {
+      if (required) {
+        console.log(`  ${Y}✗${R} ${name} ${Y}(required)${R}`)
+      } else {
+        console.log(`  ${Y}✗${R} ${name} ${D}(optional)${R}`)
+      }
+      if (fix) console.log(`    ${D}Install: ${fix}${R}`)
+      return false
+    }
+  }
+
+  // Required
+  check('Node.js', 'node --version', true)
+  check('npm', 'npm --version', true)
+  check('git', 'git --version', true)
+
+  // node-pty native addon
+  try {
+    require(path.join(ROOT, 'node_modules/node-pty'))
+    console.log(`  ${G}✓${R} node-pty ${D}(native addon loaded)${R}`)
+  } catch {
+    console.log(`  ${Y}✗${R} node-pty ${Y}(native addon failed to load)${R}`)
+    console.log(`    ${D}Run: cd ${ROOT} && npm install --omit=dev${R}`)
+  }
+
+  console.log('')
+
+  // Coding agents
+  check('Claude Code', 'claude --version', false, 'npm install -g @anthropic-ai/claude-code')
+  check('Codex CLI', 'codex --version', false, 'npm install -g @openai/codex')
+
+  console.log('')
+
+  // Desktop
+  try {
+    require.resolve('electron')
+    console.log(`  ${G}✓${R} Electron ${D}(desktop mode available)${R}`)
+  } catch {
+    console.log(`  ${D}-${R} Electron ${D}(not installed — desktop mode unavailable)${R}`)
+    console.log(`    ${D}Install: cd ${ROOT} && npm install${R}`)
+  }
+
+  // Build status
+  const headlessBuilt = fs.existsSync(path.join(ROOT, 'out/headless/index.mjs'))
+  const desktopBuilt = fs.existsSync(path.join(ROOT, 'out/main/index.js'))
+  console.log('')
+  console.log(`  ${headlessBuilt ? G + '✓' : Y + '✗'}${R} Terminal build ${D}(out/headless/index.mjs)${R}`)
+  console.log(`  ${desktopBuilt ? G + '✓' : D + '-'}${R} Desktop build ${D}(out/main/index.js)${R}`)
+
+  console.log('')
+  process.exit(0)
+}
+
+// ─── Mode detection ───────────────────────────────
+
+function detectMode(argv) {
+  if (argv.includes('--terminal')) return 'terminal'
+  if (argv.includes('--desktop')) return 'desktop'
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return 'terminal'
+  if (process.env.container || process.env.DOCKER_CONTAINER) return 'terminal'
+  if (process.platform === 'linux') {
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return 'terminal'
+  }
+  return 'desktop'
+}
+
+const mode = detectMode(args)
+
+if (mode === 'desktop') {
+  let electronPath
+  try {
+    electronPath = require('electron')
+  } catch {
+    console.error('[ctlsurf] Electron not found, falling back to terminal mode')
+    runTerminal()
+    process.exit(0)
+  }
+
+  try {
+    execFileSync(String(electronPath), [ROOT, ...args], { stdio: 'inherit' })
+  } catch (err) {
+    process.exit(err.status || 0)
+  }
+} else {
+  runTerminal()
+}
+
+function runTerminal() {
+  const terminalPath = path.join(ROOT, 'out/headless/index.mjs')
+  if (!fs.existsSync(terminalPath)) {
+    console.error('[ctlsurf] Terminal build not found. Run: npm run build:headless')
+    process.exit(1)
+  }
+  try {
+    execFileSync(process.execPath, [terminalPath, ...args], { stdio: 'inherit' })
+  } catch (err) {
+    process.exit(err.status || 0)
+  }
+}

package/electron-vite.config.ts

@@ -0,0 +1,34 @@
+import { defineConfig, externalizeDepsPlugin } from 'electron-vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  main: {
+    plugins: [externalizeDepsPlugin({
+      exclude: []
+    })],
+    build: {
+      lib: {
+        entry: 'src/main/index.ts'
+      },
+      rollupOptions: {
+        external: [
+          'electron',
+          'node-pty',
+          /^node:/
+        ]
+      }
+    },
+    resolve: {
+      conditions: ['node']
+    }
+  },
+  preload: {
+    plugins: [externalizeDepsPlugin()]
+  },
+  renderer: {
+    plugins: [react()],
+    worker: {
+      format: 'es'
+    }
+  }
+})