@superinterface/server 1.0.0 → 1.0.2

package/bin/index.cjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const path = require('node:path')
+const { register, require: tsxRequire } = require('tsx/cjs/api')
+
+register()
+
+const cliPath = path.resolve(__dirname, '../scripts/cli.ts')
+
+tsxRequire(cliPath, __filename)

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@superinterface/server",
-  "version": "1.0.0",
+  "version": "1.0.2",
+  "bin": {
+    "superinterface-server": "./bin/index.cjs"
+  },
   "exports": {
     "./prisma/enums/*": "./prisma/enums/*",
     "./prisma/*": "./prisma/*",
@@ -131,6 +134,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
+    "@clack/prompts": "^0.11.0",
     "@mendable/firecrawl-js": "^1.22.0",
     "@mistralai/mistralai": "^1.10.0",
     "@modelcontextprotocol/sdk": "^1.19.1",
@@ -141,18 +145,22 @@
     "@upstash/redis": "^1.35.5",
     "@upstash/workflow": "^0.2.20",
     "@vercel/functions": "^3.1.1",
+    "commander": "^14.0.1",
     "dayjs": "^1.11.18",
+    "dotenv": "^16.4.5",
     "groq-sdk": "^0.33.0",
     "p-iteration": "^1.1.8",
     "prisma-json-types-generator": "^3.6.2",
     "replicate": "^1.2.0",
     "supercompat": "^3.8.0",
-    "uuid": "^13.0.0"
+    "tsx": "^4.11.0",
+    "uuid": "^13.0.0",
+    "zod": "^3.23.8"
   },
   "peerDependencies": {
     "next": "15.5.4",
-    "react": "19.1.1",
-    "react-dom": "19.1.1"
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3",
@@ -163,14 +171,9 @@
     "eslint-config-next": "15.5.4",
     "next": "15.5.4",
     "prisma": "^6.16.3",
-    "react": "19.1.1",
-    "react-dom": "19.1.1",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
     "tsc-alias": "^1.8.12",
-    "typescript": "^5",
-    "@clack/prompts": "^0.11.0",
-    "dotenv": "^16.4.5",
-    "tsx": "^4.11.0",
-    "zod": "^3.23.8",
-    "commander": "^14.0.1"
+    "typescript": "^5"
   }
 }

package/scripts/cli.ts

@@ -4,16 +4,29 @@ import type { PrismaClient } from '@prisma/client'
 import { Command } from 'commander'
 import { createOrganization } from './commands/organizations/create'
 import { createOrganizationApiKey } from './commands/organizations/api-keys/create'
+import { runServer } from './commands/run/server'
 import { CliError } from './utils/errors'
 import { ensureEnv, ensureDatabaseUrl } from './utils/env'
 
 const program = new Command()
-  .name('superinterface-cli')
+  .name('@superinterface/server')
   .description('Administrative helpers for @superinterface/server')
   .showHelpAfterError('(add --help for additional information)')
 
 type ActionOptions<Options> = Options & { prisma: PrismaClient }
 
+const handleCliError = (error: unknown) => {
+  if (error instanceof CliError) {
+    console.error(error.message)
+    if (error.cause) {
+      console.error(error.cause)
+    }
+  } else {
+    console.error(error)
+  }
+  process.exitCode = 1
+}
+
 const withAction = <Options extends Record<string, unknown>>(
   action: (options: ActionOptions<Options>) => Promise<void>,
 ) => {
@@ -31,15 +44,7 @@ const withAction = <Options extends Record<string, unknown>>(
 
       await action(actionOptions)
     } catch (error) {
-      if (error instanceof CliError) {
-        console.error(error.message)
-        if (error.cause) {
-          console.error(error.cause)
-        }
-      } else {
-        console.error(error)
-      }
-      process.exitCode = 1
+      handleCliError(error)
     } finally {
       await prisma?.$disconnect()
     }
@@ -67,18 +72,39 @@ organizationApiKeys
   .option('-n, --name <name>', 'API key display name')
   .action(withAction(createOrganizationApiKey))
 
+const run = program.command('run').description('Run local services')
+
+run
+  .command('server')
+  .description('Start the server runtime')
+  .option('-r, --runtime <runtime>', 'Runtime driver (default: next)', 'next')
+  .option('-p, --port <port>', 'Port to listen on')
+  .action(async (options: { runtime?: string; port?: string }) => {
+    try {
+      const portOption = options.port
+      let parsedPort: number | undefined
+
+      if (typeof portOption === 'string') {
+        const port = Number.parseInt(portOption, 10)
+        if (!Number.isInteger(port) || port <= 0) {
+          throw new CliError('Port must be a positive integer.')
+        }
+        parsedPort = port
+      }
+
+      await runServer({
+        runtime: options.runtime,
+        port: parsedPort,
+      })
+    } catch (error) {
+      handleCliError(error)
+    }
+  })
+
 if (process.argv.length <= 2) {
   program.outputHelp()
 }
 
 program.parseAsync(process.argv).catch((error) => {
-  if (error instanceof CliError) {
-    console.error(error.message)
-    if (error.cause) {
-      console.error(error.cause)
-    }
-  } else {
-    console.error(error)
-  }
-  process.exitCode = 1
+  handleCliError(error)
 })

package/scripts/commands/run/server.ts

@@ -0,0 +1,146 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+import { CliError } from '../../utils/errors'
+import { ensureDatabaseUrl, ensureEnv } from '../../utils/env'
+
+const supportedRuntimes = ['next'] as const
+
+type SupportedRuntime = (typeof supportedRuntimes)[number]
+
+export type RunServerOptions = {
+  runtime?: string
+  port?: number
+}
+
+const isSupportedRuntime = (runtime: string): runtime is SupportedRuntime => {
+  return supportedRuntimes.includes(runtime as SupportedRuntime)
+}
+
+export const runServer = async ({
+  runtime = 'next',
+  port,
+}: RunServerOptions) => {
+  const normalizedRuntime = runtime.toLowerCase()
+
+  if (!isSupportedRuntime(normalizedRuntime)) {
+    throw new CliError(`Unsupported runtime "${runtime}".`, {
+      cause: `Supported runtimes: ${supportedRuntimes.join(', ')}`,
+    })
+  }
+
+  await ensureEnv()
+  ensureDatabaseUrl()
+
+  switch (normalizedRuntime) {
+    case 'next':
+      await runNextRuntime({ port })
+      return
+  }
+}
+
+type RunCommandOptions = {
+  label: string
+  cwd: string
+  env?: NodeJS.ProcessEnv
+}
+
+const runCommand = async (
+  command: string,
+  args: string[],
+  { label, cwd, env }: RunCommandOptions,
+) => {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'inherit',
+      env,
+    })
+
+    const forwardSignal = (signal: NodeJS.Signals) => {
+      if (!child.killed) {
+        child.kill(signal)
+      }
+    }
+
+    const onSigint = () => forwardSignal('SIGINT')
+    const onSigterm = () => forwardSignal('SIGTERM')
+
+    const cleanup = () => {
+      process.off('SIGINT', onSigint)
+      process.off('SIGTERM', onSigterm)
+    }
+
+    process.on('SIGINT', onSigint)
+    process.on('SIGTERM', onSigterm)
+
+    child.once('error', (error) => {
+      cleanup()
+      reject(new CliError(`${label} failed to start.`, { cause: error }))
+    })
+
+    child.once('exit', (code, signal) => {
+      cleanup()
+
+      if (signal) {
+        process.kill(process.pid, signal)
+        return
+      }
+
+      if (typeof code === 'number' && code !== 0) {
+        reject(new CliError(`${label} exited with code ${code}.`))
+        return
+      }
+
+      resolve()
+    })
+  })
+}
+
+type RunNextRuntimeOptions = {
+  port?: number
+}
+
+const runNextRuntime = async ({ port }: RunNextRuntimeOptions) => {
+  const packageRoot = fileURLToPath(new URL('../../..', import.meta.url))
+  const require = createRequire(import.meta.url)
+
+  let nextBinPath: string
+  try {
+    const nextPackageJson = require.resolve('next/package.json', {
+      paths: [packageRoot],
+    })
+    nextBinPath = path.resolve(path.dirname(nextPackageJson), 'dist/bin/next')
+  } catch (error) {
+    throw new CliError('Next runtime is not installed or cannot be resolved.', {
+      cause: error,
+    })
+  }
+
+  const environment = {
+    ...process.env,
+    NODE_ENV: process.env.NODE_ENV ?? 'production',
+  }
+
+  const buildIdPath = path.join(packageRoot, '.next', 'BUILD_ID')
+  if (!fs.existsSync(buildIdPath)) {
+    throw new CliError(
+      'No existing Next build found. Run `next build` before starting.',
+    )
+  }
+
+  const startArgs = ['start']
+
+  if (typeof port === 'number') {
+    startArgs.push('-p', String(port))
+  }
+
+  await runCommand(process.execPath, [nextBinPath, ...startArgs], {
+    label: 'Next runtime',
+    cwd: packageRoot,
+    env: environment,
+  })
+}

package/scripts/utils/env.ts

@@ -10,15 +10,25 @@ export const ensureEnv = async () => {
   if (envLoaded) return
 
   const proc = process as ProcessWithLoadEnvFile
+  let handled = false
 
   if (typeof proc.loadEnvFile === 'function') {
-    proc.loadEnvFile()
-    envLoaded = true
-    return
+    try {
+      proc.loadEnvFile()
+      handled = true
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException | undefined)?.code
+      if (code && code !== 'ENOENT') {
+        throw error
+      }
+    }
+  }
+
+  if (!handled) {
+    const dotenv = await import('dotenv')
+    dotenv.config({ path: '.env' })
   }
 
-  const dotenv = await import('dotenv')
-  dotenv.config({ path: '.env' })
   envLoaded = true
 }