@h-ai/cli 0.1.0-alpha.20 → 0.1.0-alpha.21

package/templates/apps/api/apps/{{projectName}}-service/src/lib/server/init.ts.hbs

@@ -0,0 +1,184 @@
+{{#if features.ai}}import type { AIConfigInput } from '@h-ai/ai'
+{{/if}}{{#if features.cache}}import type { CacheConfigInput } from '@h-ai/cache'
+{{/if}}{{#if features.iam}}import type { IamConfigInput } from '@h-ai/iam'
+{{/if}}{{#if features.crypto}}import type { ServConfig } from '@h-ai/serv'
+{{/if}}{{#if features.storage}}import type { StorageConfigInput } from '@h-ai/storage'
+{{/if}}{{#if features.ai}}import { ai, AIConfigSchema } from '@h-ai/ai'
+{{/if}}{{#if features.cache}}import { cache, CacheConfigSchema } from '@h-ai/cache'
+{{/if}}import { core } from '@h-ai/core'
+{{#if features.crypto}}import { crypto } from '@h-ai/crypto'
+{{/if}}{{#if features.iam}}import { iam, IamConfigSchema } from '@h-ai/iam'
+{{/if}}{{#if features.db}}import { reldb, ReldbConfigSchema } from '@h-ai/reldb'
+{{/if}}import { ServConfigSchema } from '@h-ai/serv'
+{{#if features.storage}}import { storage, StorageConfigSchema } from '@h-ai/storage'
+{{/if}}{{#if features.vecdb}}import { vecdb, VecdbConfigSchema } from '@h-ai/vecdb'
+{{/if}}
+
+{{#if features.db}}type DbConfigInput = Parameters<typeof reldb.init>[0]
+{{/if}}{{#if features.vecdb}}type VecdbConfigInput = Parameters<typeof vecdb.init>[0]
+{{/if}}
+
+let initialized = false
+let initPromise: Promise<void> | null = null
+{{#if features.crypto}}let cryptoInitialized = false
+{{/if}}
+
+export async function initApp(): Promise<void> {
+  if (initialized)
+    return
+  if (initPromise)
+    return initPromise
+
+  initPromise = doInit()
+  try {
+    await initPromise
+    initialized = true
+  }
+  finally {
+    initPromise = null
+  }
+}
+
+async function doInit(): Promise<void> {
+  core.init({
+    configDir: './config',
+    logging: { level: 'info' },
+  })
+
+  const servValidation = core.config.validate('serv', ServConfigSchema)
+  if (!servValidation.success) {
+    throw new Error(`Serv config invalid: ${servValidation.error.message}`)
+  }
+{{#if features.crypto}}
+  const servConfig = core.config.getOrThrow<ServConfig>('serv')
+  if (servConfig.transport !== false) {
+    const cryptoResult = await crypto.init()
+    if (!cryptoResult.success) {
+      throw new Error(`Crypto initialization failed: ${cryptoResult.error.message}`)
+    }
+    cryptoInitialized = true
+  }
+{{/if}}{{#if features.db}}
+
+  const dbValidation = core.config.validate('db', ReldbConfigSchema)
+  if (!dbValidation.success) {
+    throw new Error(`DB config invalid: ${dbValidation.error.message}`)
+  }
+{{/if}}{{#if features.cache}}
+
+  const cacheValidation = core.config.validate('cache', CacheConfigSchema)
+  if (!cacheValidation.success) {
+    throw new Error(`Cache config invalid: ${cacheValidation.error.message}`)
+  }
+{{/if}}{{#if features.vecdb}}
+
+  const vecdbValidation = core.config.validate('vecdb', VecdbConfigSchema)
+  if (!vecdbValidation.success) {
+    throw new Error(`VecDB config invalid: ${vecdbValidation.error.message}`)
+  }
+{{/if}}{{#if features.iam}}
+
+  const iamValidation = core.config.validate('iam', IamConfigSchema)
+  if (!iamValidation.success) {
+    throw new Error(`IAM config invalid: ${iamValidation.error.message}`)
+  }
+{{/if}}{{#if features.storage}}
+
+  const storageValidation = core.config.validate('storage', StorageConfigSchema)
+  if (!storageValidation.success) {
+    throw new Error(`Storage config invalid: ${storageValidation.error.message}`)
+  }
+{{/if}}{{#if features.ai}}
+
+  const aiValidation = core.config.validate('ai', AIConfigSchema)
+  if (!aiValidation.success) {
+    throw new Error(`AI config invalid: ${aiValidation.error.message}`)
+  }
+{{/if}}{{#if features.db}}
+
+  const dbConfig = core.config.getOrThrow<DbConfigInput>('db')
+{{/if}}{{#if features.cache}}  const cacheConfig = core.config.getOrThrow<CacheConfigInput>('cache')
+{{/if}}{{#if features.vecdb}}  const vecdbConfig = core.config.getOrThrow<VecdbConfigInput>('vecdb')
+{{/if}}{{#if features.iam}}  const iamConfig = core.config.getOrThrow<IamConfigInput>('iam')
+{{/if}}{{#if features.storage}}  const storageConfig = core.config.getOrThrow<StorageConfigInput>('storage')
+{{/if}}{{#if features.ai}}  const aiConfig = core.config.getOrThrow<AIConfigInput>('ai')
+{{/if}}{{#if features.db}}
+
+  if (dbConfig.type === 'sqlite') {
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+    const dbDir = path.dirname(dbConfig.database)
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true })
+    }
+  }
+
+  const dbResult = await reldb.init(dbConfig)
+  if (!dbResult.success) {
+    throw new Error(`Database initialization failed: ${dbResult.error.message}`)
+  }
+{{/if}}{{#if features.cache}}
+
+  const cacheResult = await cache.init(cacheConfig)
+  if (!cacheResult.success) {
+    throw new Error(`Cache initialization failed: ${cacheResult.error.message}`)
+  }
+{{/if}}{{#if features.vecdb}}
+
+  const vecdbResult = await vecdb.init(vecdbConfig)
+  if (!vecdbResult.success) {
+    throw new Error(`VecDB initialization failed: ${vecdbResult.error.message}`)
+  }
+{{/if}}{{#if features.iam}}
+
+  const iamResult = await iam.init(iamConfig)
+  if (!iamResult.success) {
+    throw new Error(`IAM initialization failed: ${iamResult.error.message}`)
+  }
+{{/if}}{{#if features.storage}}
+
+  const storageResult = await storage.init(storageConfig)
+  if (!storageResult.success) {
+    throw new Error(`Storage initialization failed: ${storageResult.error.message}`)
+  }
+{{/if}}{{#if features.ai}}
+
+  const aiResult = await ai.init(aiConfig)
+  if (!aiResult.success) {
+    throw new Error(`AI initialization failed: ${aiResult.error.message}`)
+  }
+{{/if}}
+
+  core.logger.info('API service initialized')
+}
+
+export async function closeApp(): Promise<void> {
+  if (!initialized && !initPromise)
+    return
+
+  const closers: Array<readonly [string, () => unknown]> = [
+{{#if features.ai}}    ['ai', () => ai.close()],
+{{/if}}{{#if features.storage}}    ['storage', () => storage.close()],
+{{/if}}{{#if features.iam}}    ['iam', () => iam.close()],
+{{/if}}{{#if features.vecdb}}    ['vecdb', () => vecdb.close()],
+{{/if}}{{#if features.cache}}    ['cache', () => cache.close()],
+{{/if}}{{#if features.db}}    ['reldb', () => reldb.close()],
+{{/if}}  ]
+{{#if features.crypto}}  if (cryptoInitialized) {
+    closers.push(['crypto', () => crypto.close()])
+  }
+{{/if}}
+
+  for (const [name, close] of closers) {
+    try {
+      await close()
+    }
+    catch (error) {
+      core.logger.warn(`Module close failed: ${name}`, { error })
+    }
+  }
+
+  initialized = false
+{{#if features.crypto}}  cryptoInitialized = false
+{{/if}}  core.logger.info('API service closed')
+}

package/templates/apps/api/apps/{{projectName}}-service/src/server/procedures/app-procedures.ts.hbs

@@ -0,0 +1,49 @@
+import type { ServContext } from '@h-ai/serv'
+{{#if features.iam}}import type { AppEchoInput, AppEchoOutputData, AppInfoOutputData } from '{{api.contractPackageName}}'
+{{else}}import type { AppEchoOutputData, AppInfoOutputData } from '{{api.contractPackageName}}'
+{{/if}}
+import { ok } from '@h-ai/core'
+import { serv } from '@h-ai/serv'
+import { appContract } from '{{api.contractPackageName}}'
+
+export interface AppProcedureDeps {
+  readonly info: {
+    readonly name: string
+    readonly version: string
+    readonly transportEnabled: boolean
+  }
+  readonly startedAt: number
+}
+
+const p = serv.implement(appContract).$context<ServContext>()
+
+/** 创建应用自有 procedures。 */
+export function createAppProcedures(deps: AppProcedureDeps) {
+  return p.router({
+    info: p.info.handler(() => {
+      const data: AppInfoOutputData = {
+        name: deps.info.name,
+        version: deps.info.version,
+        transportEnabled: deps.info.transportEnabled,
+        uptimeMs: Math.max(0, Date.now() - deps.startedAt),
+      }
+      return ok(data)
+    }),
+    echo: {{#if features.iam}}p.echo.handler(serv.requireAuth<AppEchoInput, AppEchoOutputData>(({ input, context }) => {
+      const data: AppEchoOutputData = {
+        message: input.message,
+        userId: context.session!.userId,
+        requestId: context.requestId,
+        timestamp: new Date().toISOString(),
+      }
+      return Promise.resolve(ok(data))
+    })){{else}}p.echo.handler(({ input, context }) => {
+      const data: AppEchoOutputData = {
+        message: input.message,
+        requestId: context.requestId,
+        timestamp: new Date().toISOString(),
+      }
+      return ok(data)
+    }){{/if}},
+  })
+}

package/templates/apps/api/apps/{{projectName}}-service/src/server/procedures/index.ts.hbs

@@ -0,0 +1,18 @@
+import type { AppProcedureDeps } from './app-procedures.js'
+{{#if features.ai}}import { ai } from '@h-ai/ai'
+{{/if}}{{#if features.iam}}import { iam } from '@h-ai/iam'
+{{/if}}{{#if features.ai}}import { createAiProcedures } from '@h-ai/serv/features/ai'
+{{/if}}{{#if features.iam}}import { createIamProcedures } from '@h-ai/serv/features/iam'
+{{/if}}{{#if features.storage}}import { createStorageProcedures } from '@h-ai/serv/features/storage'
+import { storage } from '@h-ai/storage'
+{{/if}}import { createAppProcedures } from './app-procedures.js'
+
+/** 创建应用级 procedures 聚合。 */
+export function {{api.serviceProceduresFactoryName}}(deps: { app: AppProcedureDeps }) {
+  return {
+{{#if features.iam}}    iam: createIamProcedures({ iam }),
+{{/if}}{{#if features.storage}}    storage: createStorageProcedures({ storage }),
+{{/if}}{{#if features.ai}}    ai: createAiProcedures({ ai }),
+{{/if}}    app: createAppProcedures(deps.app),
+  }
+}

package/templates/apps/api/apps/{{projectName}}-service/tests/service.test.ts.hbs

@@ -0,0 +1,168 @@
+import type { AddressInfo } from 'node:net'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+{{#if features.ai}}import { ai } from '@h-ai/ai'
+{{/if}}import { apiClient } from '@h-ai/api-client'
+{{#if features.cache}}import { cache } from '@h-ai/cache'
+{{/if}}import { core } from '@h-ai/core'
+{{#if features.iam}}import { iam } from '@h-ai/iam'
+{{/if}}{{#if features.db}}import { reldb } from '@h-ai/reldb'
+{{/if}}import { serv } from '@h-ai/serv'
+{{#if features.storage}}import { storage } from '@h-ai/storage'
+{{/if}}{{#if features.vecdb}}import { vecdb } from '@h-ai/vecdb'
+{{/if}}import { {{api.contractExportName}} } from '{{api.contractPackageName}}'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+import { {{api.serviceAppFactoryName}} } from '../src/app.js'
+
+let tempRoot = ''
+let baseUrl = ''
+let client: ReturnType<typeof apiClient.create<typeof {{api.contractExportName}}>>
+let server: ReturnType<typeof serv.listen>
+{{#if features.storage}}let storageRoot = ''
+{{/if}}{{#if features.vecdb}}let vecdbRoot = ''
+{{/if}}
+
+{{#if features.iam}}
+function uniqueUser(prefix = 'api') {
+  const suffix = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`.slice(-8)
+  return {
+    username: `${prefix}_${suffix}`,
+    password: 'TestPass123',
+    email: `${prefix}_${suffix}@test.local`,
+  }
+}
+{{/if}}
+
+beforeAll(async () => {
+  tempRoot = mkdtempSync(join(tmpdir(), '{{projectName}}-service-test-'))
+{{#if features.storage}}  storageRoot = join(tempRoot, 'storage')
+{{/if}}{{#if features.vecdb}}  vecdbRoot = join(tempRoot, 'vecdb')
+{{/if}}
+
+  core.init({
+    configDir: './config',
+    logging: { level: 'warn' },
+  })
+{{#if features.db}}
+
+  const dbResult = await reldb.init({ type: 'sqlite', database: ':memory:' })
+  if (!dbResult.success)
+    throw new Error(`reldb: ${dbResult.error.message}`)
+{{/if}}{{#if features.cache}}
+
+  const cacheResult = await cache.init({ type: 'memory' })
+  if (!cacheResult.success)
+    throw new Error(`cache: ${cacheResult.error.message}`)
+{{/if}}{{#if features.vecdb}}
+
+  const vecdbResult = await vecdb.init({ type: 'lancedb', path: vecdbRoot })
+  if (!vecdbResult.success)
+    throw new Error(`vecdb: ${vecdbResult.error.message}`)
+{{/if}}{{#if features.iam}}
+
+  const iamResult = await iam.init({})
+  if (!iamResult.success)
+    throw new Error(`iam: ${iamResult.error.message}`)
+{{/if}}{{#if features.storage}}
+
+  const storageResult = await storage.init({ type: 'local', root: storageRoot })
+  if (!storageResult.success)
+    throw new Error(`storage: ${storageResult.error.message}`)
+{{/if}}{{#if features.ai}}
+
+  const aiResult = await ai.init({})
+  if (!aiResult.success)
+    throw new Error(`ai: ${aiResult.error.message}`)
+{{/if}}
+
+  const app = {{api.serviceAppFactoryName}}({
+    transport: 'disabled',{{#if features.iam}}
+    refreshCookie: 'disabled',{{/if}}
+  })
+  const listening = new Promise<AddressInfo>((resolve) => {
+    server = serv.listen(app, {
+      host: '127.0.0.1',
+      port: 0,
+      onListening: info => resolve(info as AddressInfo),
+    })
+  })
+  const address = await listening
+  baseUrl = `http://127.0.0.1:${address.port}`
+
+  client = apiClient.create({{api.contractExportName}})
+  const initResult = await client.init({
+    baseUrl: `${baseUrl}/api/v1`,
+    auth: { storage: apiClient.tokenStorage.memory() },
+  })
+  if (!initResult.success)
+    throw new Error(`client.init: ${initResult.error.message}`)
+}, 30_000)
+
+afterAll(async () => {
+  await client?.close()
+  await server?.close()
+{{#if features.ai}}  await ai.close()
+{{/if}}{{#if features.storage}}  await storage.close()
+{{/if}}{{#if features.iam}}  await iam.close()
+{{/if}}{{#if features.vecdb}}  await vecdb.close()
+{{/if}}{{#if features.cache}}  await cache.close()
+{{/if}}{{#if features.db}}  await reldb.close()
+{{/if}}  rmSync(tempRoot, { recursive: true, force: true })
+})
+
+describe('{{api.servicePackageName}}', () => {
+  it('returns health status', async () => {
+    const response = await fetch(`${baseUrl}/health`)
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({ status: 'ok' })
+  })
+
+  it('returns app info as HaiResult', async () => {
+    const result = await client.app.info()
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.name).toContain('{{projectName}}')
+      expect(typeof result.data.transportEnabled).toBe('boolean')
+    }
+  })
+
+  it('validates echo input', async () => {
+    const result = await client.app.echo({ message: '' })
+
+    expect(result.success).toBe(false)
+  })
+
+{{#if features.iam}}
+  it('registers a user and returns authenticated echo context', async () => {
+    const user = uniqueUser('svc')
+    const register = await client.iam.auth.register({
+      username: user.username,
+      password: user.password,
+      email: user.email,
+    })
+
+    expect(register.success).toBe(true)
+
+    const result = await client.app.echo({ message: 'hello unit' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.message).toBe('hello unit')
+      expect(result.data.userId).toBeTruthy()
+    }
+  })
+{{else}}
+  it('returns echo result as HaiResult', async () => {
+    const result = await client.app.echo({ message: 'hello unit' })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.message).toBe('hello unit')
+      expect(result.data.userId).toBeUndefined()
+    }
+  })
+{{/if}}
+})

package/templates/apps/api/apps/{{projectName}}-service/tsconfig.json.hbs

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "types": ["node"],
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/templates/apps/api/apps/{{projectName}}-service/tsup.config.ts.hbs

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  target: 'node22',
+  sourcemap: true,
+  clean: true,
+  dts: false,
+  external: ['@lancedb/lancedb'],
+})

package/templates/apps/api/apps/{{projectName}}-service/vitest.config.ts.hbs

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+})

package/templates/apps/api/e2e/api-service.spec.ts.hbs

@@ -0,0 +1,18 @@
+import { expect, test } from '@playwright/test'
+
+test('service health endpoint returns ok', async ({ request }) => {
+  const response = await request.get('/health')
+
+  expect(response.status()).toBe(200)
+  await expect(response.json()).resolves.toEqual({ status: 'ok' })
+})
+
+test('service app.info endpoint returns HaiResult', async ({ request }) => {
+  const response = await request.post('/api/v1/app/info')
+  const body = await response.json()
+
+  expect(response.status()).toBe(200)
+  expect(body.success).toBe(true)
+  expect(body.data.name).toContain('{{projectName}}')
+  expect(typeof body.data.transportEnabled).toBe('boolean')
+})

package/templates/apps/api/eslint.config.js

@@ -0,0 +1,32 @@
+import antfu from '@antfu/eslint-config'
+
+export default antfu({
+  formatters: true,
+  ignores: [
+    '**/dist/**',
+    '**/node_modules/**',
+    '**/.agents/**',
+    '**/.github/**',
+    '**/AGENTS.md',
+    '**/CLAUDE.md',
+    '**/README.md',
+    '**/opencode.json',
+    '**/package.json',
+  ],
+}, {
+  files: ['**/*.js', '**/*.mjs', '**/*.ts'],
+  rules: {
+    'no-console': 'error',
+    'ts/no-explicit-any': 'error',
+  },
+}, {
+  files: ['**/tsconfig.json', '**/tsconfig.*.json'],
+  rules: {
+    'jsonc/sort-keys': 'off',
+  },
+}, {
+  files: ['**/index.ts'],
+  rules: {
+    'perfectionist/sort-exports': 'off',
+  },
+})

package/templates/apps/api/package.json.hbs

@@ -0,0 +1,29 @@
+{
+  "name": "{{projectName}}",
+  "type": "module",
+  "version": "0.1.0",
+  "private": true,
+  "packageManager": "pnpm@9.15.0",
+  "description": "Typed hai API workspace with separated contract and service packages.",
+  "scripts": {
+    "dev": "pnpm --filter {{api.servicePackageName}} dev",
+    "compile": "pnpm typecheck && pnpm build",
+    "build": "pnpm --filter {{api.contractPackageName}} build && pnpm -r --if-present build",
+    "typecheck": "pnpm --filter {{api.contractPackageName}} build && pnpm -r --if-present typecheck",
+    "lint": "pnpm -r --if-present lint",
+    "test": "pnpm --filter {{api.contractPackageName}} build && pnpm -r --if-present test",
+    "test:e2e": "pnpm build && playwright test",
+    "clean": "pnpm -r --if-present clean && rimraf node_modules .turbo"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "{{api.packageSpecifiers.antfuEslintConfig}}",
+    "@playwright/test": "{{api.packageSpecifiers.playwright}}",
+    "@types/node": "{{api.packageSpecifiers.nodeTypes}}",
+    "eslint": "{{api.packageSpecifiers.eslint}}",
+    "eslint-plugin-format": "{{api.packageSpecifiers.eslintPluginFormat}}",
+    "rimraf": "{{api.packageSpecifiers.rimraf}}",
+    "tsup": "{{api.packageSpecifiers.tsup}}",
+    "typescript": "{{api.packageSpecifiers.typescript}}",
+    "vitest": "{{api.packageSpecifiers.vitest}}"
+  }
+}

package/templates/apps/api/playwright.config.ts.hbs

@@ -0,0 +1,58 @@
+import process from 'node:process'
+import { defineConfig } from '@playwright/test'
+
+const defaultBaseURL = 'http://127.0.0.1:3000'
+const baseURL = process.env.BASE_URL || defaultBaseURL
+const serviceHost = resolveHostFromBaseUrl(baseURL, '127.0.0.1')
+const servicePort = resolvePortFromBaseUrl(baseURL, '3000')
+
+function resolveHostFromBaseUrl(urlString: string, fallbackHost: string): string {
+  try {
+    const url = new URL(urlString)
+    return url.hostname || fallbackHost
+  }
+  catch {
+    return fallbackHost
+  }
+}
+
+function resolvePortFromBaseUrl(urlString: string, fallbackPort: string): string {
+  try {
+    const url = new URL(urlString)
+    if (url.port) {
+      return url.port
+    }
+
+    return url.protocol === 'https:' ? '443' : '80'
+  }
+  catch {
+    return fallbackPort
+  }
+}
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: 1,
+  reporter: 'list',
+  timeout: 30_000,
+  use: {
+    baseURL,
+    channel: 'chrome',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+  webServer: [{
+    name: '{{api.servicePackageName}}',
+    command: 'pnpm --filter {{api.servicePackageName}} start',
+    env: {
+      HOST: serviceHost,
+      PORT: servicePort,
+    },
+    url: `${baseURL}/health`,
+    reuseExistingServer: false,
+    timeout: 120_000,
+  }],
+})

package/templates/apps/api/pnpm-workspace.yaml.hbs

@@ -0,0 +1,14 @@
+{{! @skipIfEmpty }}
+shellEmulator: true
+
+trustPolicy: no-downgrade
+
+packages:
+  - apps/*
+
+{{#if useCatalogProtocol}}
+catalog:
+{{#each haiCatalogPackages}}
+  '{{@key}}': {{this}}
+{{/each}}
+{{/if}}

package/templates/apps/api/tsconfig.base.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "resolveJsonModule": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  }
+}

package/templates/apps/fullstack/apps/{{projectName}}-app/.env.example.hbs

@@ -0,0 +1,10 @@
+{{! @skipIfEmpty }}
+{{#if fullstack.frontends.app}}
+# {{projectName}}-app — 环境变量
+# Android 模拟器访问宿主机后端时通常使用 http://10.0.2.2:3000。
+
+PUBLIC_API_BASE=http://localhost:3000
+
+# 仅用于 Capacitor live reload 前端页面。
+# CAPACITOR_SERVER_URL=http://localhost:{{fullstack.ports.app}}
+{{/if}}