@ysk-kit/cli 1.0.0

package/templates/capabilities/llm/apps/api/src/modules/llm/infra/prisma-usage-repository.ts

@@ -0,0 +1,17 @@
+import type { PrismaClient } from '../../../generated/prisma/client';
+import type { ILlmUsageRepository } from '../domain/usage-repository';
+
+export const createPrismaLlmUsageRepository = (prisma: PrismaClient): ILlmUsageRepository => ({
+  async create(input) {
+    await prisma.llmUsage.create({
+      data: {
+        userId: input.userId,
+        model: input.model,
+        promptTokens: input.usage.promptTokens,
+        completionTokens: input.usage.completionTokens,
+        totalTokens: input.usage.totalTokens,
+        ...(input.requestId ? { requestId: input.requestId } : {}),
+      },
+    });
+  },
+});

package/templates/capabilities/llm/apps/web/src/features/llm/llm-page.tsx

@@ -0,0 +1,53 @@
+import { Button, Input } from '@ysk-kit/ui';
+import { createLlmHooks } from '@ysk-kit/web-sdk';
+import { type FormEvent, useState } from 'react';
+import { api } from '../../lib/client';
+
+const llmHooks = createLlmHooks(api);
+
+export function LlmPage() {
+  const complete = llmHooks.useLlmComplete();
+  const [prompt, setPrompt] = useState('');
+  const [formError, setFormError] = useState<string | null>(null);
+
+  const onSubmit = (event: FormEvent) => {
+    event.preventDefault();
+    if (prompt.trim().length === 0) return;
+    complete.mutate(
+      { messages: [{ role: 'user', content: prompt.trim() }] },
+      { onError: (error) => setFormError(error.message) },
+    );
+  };
+
+  return (
+    <section className="space-y-4">
+      <h1 className="text-2xl font-semibold">LLM</h1>
+      <p className="text-sm text-zinc-600">
+        One-shot complete via SpaceXAI-compatible /v1/llm/complete.
+      </p>
+      <form onSubmit={onSubmit} className="grid gap-3">
+        <label className="grid gap-1 text-sm" htmlFor="llm-prompt">
+          Prompt
+          <Input
+            id="llm-prompt"
+            value={prompt}
+            onChange={(e) => setPrompt(e.target.value)}
+            required
+          />
+        </label>
+        <Button type="submit" disabled={complete.isPending}>
+          Send
+        </Button>
+      </form>
+      {formError ? <p className="text-sm text-red-600">{formError}</p> : null}
+      {complete.data ? (
+        <div className="space-y-2 rounded-md border border-zinc-200 bg-white p-3 text-sm">
+          <p className="whitespace-pre-wrap">{complete.data.text}</p>
+          <p className="text-zinc-500">
+            {complete.data.model} · {complete.data.usage.totalTokens} tokens
+          </p>
+        </div>
+      ) : null}
+    </section>
+  );
+}

package/templates/capabilities/llm/packages/contracts/src/api/llm.ts

@@ -0,0 +1,26 @@
+import { initContract } from '@ts-rest/core';
+import { LlmCompleteCommandSchema, LlmCompleteDtoSchema, LlmModelsDtoSchema } from '../dto/llm';
+import { ErrSchema, OkSchema } from '../errors/envelope';
+
+const c = initContract();
+
+export const llmContract = c.router({
+  complete: {
+    method: 'POST',
+    path: '/v1/llm/complete',
+    body: LlmCompleteCommandSchema,
+    responses: {
+      200: OkSchema(LlmCompleteDtoSchema),
+      401: ErrSchema,
+      403: ErrSchema,
+      503: ErrSchema,
+    },
+    summary: 'One-shot chat completion',
+  },
+  models: {
+    method: 'GET',
+    path: '/v1/llm/models',
+    responses: { 200: OkSchema(LlmModelsDtoSchema), 401: ErrSchema, 403: ErrSchema },
+    summary: 'Configured models',
+  },
+});

package/templates/capabilities/llm/packages/contracts/src/dto/llm.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { LlmRoleSchema } from '../enums/llm-role';
+
+export const LlmMessageSchema = z.object({
+  role: LlmRoleSchema,
+  content: z.string().min(1).max(32_000),
+});
+export type LlmMessage = z.infer<typeof LlmMessageSchema>;
+
+export const LlmCompleteCommandSchema = z.object({
+  messages: z.array(LlmMessageSchema).min(1).max(50),
+  temperature: z.number().min(0).max(2).optional(),
+});
+export type LlmCompleteCommand = z.infer<typeof LlmCompleteCommandSchema>;
+
+export const LlmUsageSchema = z.object({
+  promptTokens: z.number().int().nonnegative(),
+  completionTokens: z.number().int().nonnegative(),
+  totalTokens: z.number().int().nonnegative(),
+});
+export type LlmUsage = z.infer<typeof LlmUsageSchema>;
+
+export const LlmCompleteDtoSchema = z.object({
+  text: z.string(),
+  model: z.string(),
+  usage: LlmUsageSchema,
+});
+export type LlmCompleteDto = z.infer<typeof LlmCompleteDtoSchema>;
+
+export const LlmModelsDtoSchema = z.object({
+  items: z.array(z.object({ id: z.string() })),
+});
+export type LlmModelsDto = z.infer<typeof LlmModelsDtoSchema>;

package/templates/capabilities/llm/packages/sdk/src/resources/llm.ts

@@ -0,0 +1,68 @@
+import type {
+  LlmCompleteCommand,
+  LlmCompleteDto,
+  LlmModelsDto,
+  LlmUsage,
+  Platform,
+} from '@ysk-kit/contracts';
+import type { HttpClient } from '../http';
+import type { TokenStore } from '../token-store';
+
+export const llmResource = (
+  http: HttpClient,
+  ctx: { baseUrl: string; platform: Platform; tokenStore: TokenStore; fetchImpl?: typeof fetch },
+) => ({
+  complete: (body: LlmCompleteCommand) =>
+    http.request<LlmCompleteDto>('/v1/llm/complete', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    }),
+  models: () => http.request<LlmModelsDto>('/v1/llm/models'),
+  stream: async (
+    body: LlmCompleteCommand,
+    handlers: {
+      onDelta: (delta: string) => void;
+      onDone: (usage?: LlmUsage) => void;
+      onError?: (message: string) => void;
+    },
+  ) => {
+    const fetchImpl = ctx.fetchImpl ?? fetch;
+    const token = await ctx.tokenStore.get();
+    const headers = new Headers({
+      'content-type': 'application/json',
+      'x-ysk-platform': ctx.platform,
+    });
+    if (token) headers.set('authorization', `Bearer ${token}`);
+    const res = await fetchImpl(`${ctx.baseUrl}/v1/llm/stream`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+    if (!res.ok || !res.body) {
+      handlers.onError?.(`HTTP ${res.status}`);
+      return;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split('\n\n');
+      buffer = parts.pop() ?? '';
+      for (const part of parts) {
+        const eventLine = part.split('\n').find((line) => line.startsWith('event:'));
+        const dataLine = part.split('\n').find((line) => line.startsWith('data:'));
+        if (!dataLine) continue;
+        const json = JSON.parse(dataLine.slice(5).trim()) as {
+          delta?: string;
+          done?: boolean;
+          usage?: LlmUsage;
+        };
+        if (eventLine?.includes('done') || json.done) handlers.onDone(json.usage);
+        else if (json.delta) handlers.onDelta(json.delta);
+      }
+    }
+  },
+});

package/templates/capabilities/llm/packages/web-sdk/src/llm-hooks.ts

@@ -0,0 +1,12 @@
+import { useMutation } from '@tanstack/react-query';
+import type { LlmCompleteCommand } from '@ysk-kit/contracts';
+import type { YskClient } from '@ysk-kit/sdk';
+
+export function createLlmHooks(client: YskClient) {
+  return {
+    useLlmComplete: () =>
+      useMutation({
+        mutationFn: (body: LlmCompleteCommand) => client.llm.complete(body),
+      }),
+  };
+}

package/templates/capabilities/push/apps/api/src/modules/devices/application/device-service.ts

@@ -0,0 +1,42 @@
+import { createHash } from 'node:crypto';
+import type { DeviceDto, RegisterDeviceCommand } from '@ysk-kit/contracts';
+import { AppError } from '@ysk-kit/domain-kernel';
+import type { IDeviceRepository } from '../domain/device-repository';
+
+export const hashDeviceToken = (token: string): string =>
+  createHash('sha256').update(token).digest('hex');
+
+const toDto = (row: {
+  id: string;
+  platform: DeviceDto['platform'];
+  token: string;
+  createdAt: Date;
+}): DeviceDto => ({
+  id: row.id,
+  platform: row.platform,
+  tokenSuffix: row.token.slice(-8),
+  createdAt: row.createdAt.toISOString(),
+});
+
+export const createDeviceService = (devices: IDeviceRepository) => ({
+  list: async (userId: string): Promise<DeviceDto[]> => {
+    const rows = await devices.listForUser(userId);
+    return rows.map(toDto);
+  },
+  register: async (userId: string, body: RegisterDeviceCommand): Promise<DeviceDto> => {
+    const row = await devices.upsert({
+      userId,
+      platform: body.platform,
+      tokenHash: hashDeviceToken(body.token),
+      token: body.token,
+    });
+    return toDto(row);
+  },
+  remove: async (id: string, userId: string) => {
+    const ok = await devices.deleteOwn(id, userId);
+    if (!ok) throw new AppError('NOT_FOUND');
+    return { removed: true as const };
+  },
+});
+
+export type DeviceService = ReturnType<typeof createDeviceService>;

package/templates/capabilities/push/apps/api/src/modules/devices/domain/device-repository.ts

@@ -0,0 +1,22 @@
+import type { DevicePlatform } from '@ysk-kit/contracts';
+
+export type DeviceRecord = {
+  id: string;
+  userId: string;
+  platform: DevicePlatform;
+  tokenHash: string;
+  token: string;
+  createdAt: Date;
+};
+
+export interface IDeviceRepository {
+  upsert(input: {
+    userId: string;
+    platform: DevicePlatform;
+    tokenHash: string;
+    token: string;
+  }): Promise<DeviceRecord>;
+  listForUser(userId: string): Promise<DeviceRecord[]>;
+  deleteOwn(id: string, userId: string): Promise<boolean>;
+  deleteByTokenHash(tokenHash: string): Promise<void>;
+}

package/templates/capabilities/push/apps/api/src/modules/devices/infra/device-router.ts

@@ -0,0 +1,42 @@
+import { type HttpHandler, mountContract } from '@ysk-kit/api-express';
+import { appContract, type RegisterDeviceCommand } from '@ysk-kit/contracts';
+import { AppError } from '@ysk-kit/domain-kernel';
+import type { Express } from 'express';
+import type { DeviceService } from '../application/device-service';
+
+export const deviceHandlers = (service: DeviceService): Record<string, HttpHandler> => ({
+  list: {
+    auth: 'required',
+    handle: async ({ auth }) => {
+      if (!auth) throw new AppError('UNAUTHENTICATED');
+      return { status: 200, body: { ok: true, data: await service.list(auth.sub) } };
+    },
+  },
+  register: {
+    auth: 'required',
+    handle: async ({ body, auth }) => {
+      if (!auth) throw new AppError('UNAUTHENTICATED');
+      return {
+        status: 200,
+        body: { ok: true, data: await service.register(auth.sub, body as RegisterDeviceCommand) },
+      };
+    },
+  },
+  remove: {
+    auth: 'required',
+    handle: async ({ params, auth }) => {
+      if (!auth) throw new AppError('UNAUTHENTICATED');
+      return {
+        status: 200,
+        body: {
+          ok: true,
+          data: await service.remove((params as { id: string }).id, auth.sub),
+        },
+      };
+    },
+  },
+});
+
+export const registerDeviceRoutes = (app: Express, service: DeviceService): void => {
+  mountContract(app, appContract.devices, deviceHandlers(service));
+};

package/templates/capabilities/push/apps/api/src/modules/devices/infra/device.app.test.ts

@@ -0,0 +1,34 @@
+import request from 'supertest';
+import { describe, expect, it } from 'vitest';
+import { createApp } from '../../../app';
+import { createMemoryInput } from '../../../create-memory-input';
+
+describe('devices http', () => {
+  it('registers a device without exposing the full token and pushes on notify', async () => {
+    const mem = createMemoryInput();
+    const app = createApp(mem.input);
+    const registered = await request(app).post('/v1/auth/register').send({
+      email: 'dev@ysk.hk',
+      password: 'password1',
+      displayName: 'Ki',
+    });
+    const token = registered.body.data.accessToken as string;
+    const created = await request(app)
+      .put('/v1/me/devices')
+      .set('authorization', `Bearer ${token}`)
+      .send({ token: 'ExponentPushToken[abcdefghijklmnop]', platform: 'ios' });
+    expect(created.status).toBe(200);
+    expect(created.body.data.tokenSuffix).toHaveLength(8);
+    expect(JSON.stringify(created.body)).not.toContain('ExponentPushToken');
+    const list = await request(app).get('/v1/me/devices').set('authorization', `Bearer ${token}`);
+    expect(list.body.data).toHaveLength(1);
+    await request(app).post('/v1/auth/forgot').send({ email: 'dev@ysk.hk' });
+    expect(mem.push.sink.some((row) => row.title === '重設密碼')).toBe(true);
+  });
+
+  it('rejects devices without a token', async () => {
+    const app = createApp(createMemoryInput().input);
+    const res = await request(app).get('/v1/me/devices');
+    expect(res.status).toBe(401);
+  });
+});

package/templates/capabilities/push/apps/api/src/modules/devices/infra/memory-device-repository.ts

@@ -0,0 +1,33 @@
+import type { DeviceRecord, IDeviceRepository } from '../domain/device-repository';
+
+export const createMemoryDeviceRepository = (): IDeviceRepository => {
+  const rows: DeviceRecord[] = [];
+  return {
+    async upsert(input) {
+      const existing = rows.find(
+        (row) => row.userId === input.userId && row.tokenHash === input.tokenHash,
+      );
+      if (existing) {
+        existing.token = input.token;
+        existing.platform = input.platform;
+        return existing;
+      }
+      const row: DeviceRecord = { id: crypto.randomUUID(), createdAt: new Date(), ...input };
+      rows.push(row);
+      return row;
+    },
+    async listForUser(userId) {
+      return rows.filter((row) => row.userId === userId);
+    },
+    async deleteOwn(id, userId) {
+      const index = rows.findIndex((row) => row.id === id && row.userId === userId);
+      if (index < 0) return false;
+      rows.splice(index, 1);
+      return true;
+    },
+    async deleteByTokenHash(tokenHash) {
+      const index = rows.findIndex((row) => row.tokenHash === tokenHash);
+      if (index >= 0) rows.splice(index, 1);
+    },
+  };
+};

package/templates/capabilities/push/apps/api/src/modules/devices/infra/prisma-device-repository.ts

@@ -0,0 +1,42 @@
+import type { DevicePlatform } from '@ysk-kit/contracts';
+import type { PrismaClient } from '../../../generated/prisma/client';
+import type { DeviceRecord, IDeviceRepository } from '../domain/device-repository';
+
+const toRecord = (row: {
+  id: string;
+  userId: string;
+  platform: string;
+  tokenHash: string;
+  token: string;
+  createdAt: Date;
+}): DeviceRecord => ({
+  ...row,
+  platform: row.platform as DevicePlatform,
+});
+
+export const createPrismaDeviceRepository = (prisma: PrismaClient): IDeviceRepository => ({
+  async upsert(input) {
+    const row = await prisma.device.upsert({
+      where: { userId_tokenHash: { userId: input.userId, tokenHash: input.tokenHash } },
+      create: input,
+      update: { token: input.token, platform: input.platform },
+    });
+    return toRecord(row);
+  },
+  async listForUser(userId) {
+    const rows = await prisma.device.findMany({
+      where: { userId },
+      orderBy: { createdAt: 'desc' },
+    });
+    return rows.map(toRecord);
+  },
+  async deleteOwn(id, userId) {
+    const row = await prisma.device.findFirst({ where: { id, userId } });
+    if (!row) return false;
+    await prisma.device.delete({ where: { id } });
+    return true;
+  },
+  async deleteByTokenHash(tokenHash) {
+    await prisma.device.deleteMany({ where: { tokenHash } });
+  },
+});

package/templates/capabilities/push/apps/mobile/src/adapters/push.ts

@@ -0,0 +1,21 @@
+import type { DevicePort, YskClient } from '@ysk-kit/sdk';
+
+export const createDevicePort = (opts: {
+  api: YskClient;
+  platform: 'ios' | 'android';
+}): DevicePort => ({
+  platform: opts.platform,
+  registerPushToken: async (token) => {
+    await opts.api.devices.register({ token, platform: opts.platform });
+  },
+});
+
+export const enablePush = async (
+  port: DevicePort,
+  getToken: () => Promise<string | null>,
+): Promise<boolean> => {
+  const token = await getToken();
+  if (!token) return false;
+  await port.registerPushToken(token);
+  return true;
+};

package/templates/capabilities/push/packages/contracts/src/api/devices.ts

@@ -0,0 +1,33 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import { DeviceDtoSchema, RegisterDeviceCommandSchema } from '../dto/device';
+import { ErrSchema, OkSchema } from '../errors/envelope';
+
+const c = initContract();
+
+export const devicesContract = c.router({
+  list: {
+    method: 'GET',
+    path: '/v1/me/devices',
+    responses: { 200: OkSchema(z.array(DeviceDtoSchema)), 401: ErrSchema },
+    summary: 'List my devices',
+  },
+  register: {
+    method: 'PUT',
+    path: '/v1/me/devices',
+    body: RegisterDeviceCommandSchema,
+    responses: { 200: OkSchema(DeviceDtoSchema), 401: ErrSchema, 422: ErrSchema },
+    summary: 'Register or refresh a push token',
+  },
+  remove: {
+    method: 'DELETE',
+    path: '/v1/me/devices/:id',
+    pathParams: z.object({ id: z.string().uuid() }),
+    responses: {
+      200: OkSchema(z.object({ removed: z.literal(true) })),
+      401: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'Remove a device',
+  },
+});

package/templates/capabilities/push/packages/contracts/src/dto/device.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export const DevicePlatformSchema = z.enum(['ios', 'android']);
+export type DevicePlatform = z.infer<typeof DevicePlatformSchema>;
+
+export const RegisterDeviceCommandSchema = z.object({
+  token: z.string().min(8).max(4096),
+  platform: DevicePlatformSchema,
+});
+export type RegisterDeviceCommand = z.infer<typeof RegisterDeviceCommandSchema>;
+
+export const DeviceDtoSchema = z.object({
+  id: z.string().uuid(),
+  platform: DevicePlatformSchema,
+  tokenSuffix: z.string().min(1).max(8),
+  createdAt: z.iso.datetime(),
+});
+export type DeviceDto = z.infer<typeof DeviceDtoSchema>;

package/templates/capabilities/push/packages/sdk/src/resources/devices.ts

@@ -0,0 +1,10 @@
+import type { DeviceDto, RegisterDeviceCommand } from '@ysk-kit/contracts';
+import type { HttpClient } from '../http';
+
+export const devicesResource = (http: HttpClient) => ({
+  list: () => http.request<DeviceDto[]>('/v1/me/devices'),
+  register: (body: RegisterDeviceCommand) =>
+    http.request<DeviceDto>('/v1/me/devices', { method: 'PUT', body: JSON.stringify(body) }),
+  remove: (id: string) =>
+    http.request<{ removed: true }>(`/v1/me/devices/${id}`, { method: 'DELETE' }),
+});