create-next-imagicma 0.1.2 → 0.1.4

package/template-hono/process-compose.yaml

@@ -1,5 +1,4 @@
 version: "0.5"
-log_location: ".opencode/logs/process-compose.log"
 
 processes:
   web:

package/template-hono/scripts/imagicma-dev.mjs

@@ -1,29 +1,20 @@
-import { spawn } from "node:child_process";
 import path from "node:path";
 import { ROOT_DIR, readLockedPort } from "./imagicma-common.mjs";
+import { startLoggedProcess } from "./imagicma-runtime-logs.mjs";
 
 const viteBin = path.join(ROOT_DIR, "node_modules", "vite", "bin", "vite.js");
 const port = await readLockedPort();
 
-const child = spawn(
-  process.execPath,
-  [viteBin, "--host", "0.0.0.0", "--port", String(port), "--strictPort"],
-  {
-    cwd: ROOT_DIR,
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      IMAGICMA_SCRIPT_LAUNCH: "1",
-      IMAGICMA_LAUNCH_MODE: "dev",
-    },
+await startLoggedProcess({
+  processName: "web",
+  mode: "dev",
+  command: process.execPath,
+  args: [viteBin, "--host", "0.0.0.0", "--port", String(port), "--strictPort"],
+  cwd: ROOT_DIR,
+  expectedPort: port,
+  env: {
+    ...process.env,
+    IMAGICMA_SCRIPT_LAUNCH: "1",
+    IMAGICMA_LAUNCH_MODE: "dev",
   },
-);
-
-child.on("close", (code) => {
-  process.exit(code ?? 0);
-});
-
-child.on("error", (error) => {
-  console.error(`[imagicma] 启动 dev 失败：${error.message}`);
-  process.exit(1);
 });

package/template-hono/scripts/imagicma-runtime-logs.mjs

@@ -0,0 +1,314 @@
+import crypto from "node:crypto";
+import rawFs from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { ROOT_DIR } from "./imagicma-common.mjs";
+
+const RUNTIME_ROOT = path.join(ROOT_DIR, ".imagicma", "runtime");
+const HISTORY_ROOT = path.join(RUNTIME_ROOT, ".history");
+const WORKFLOW_EVENT_LOG = path.join(RUNTIME_ROOT, "events.jsonl");
+const ANSI_PATTERN =
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*|(?:\d{1,4}(?:;\d{0,4})*)?)[\dA-PR-TZcf-nq-uy=><~])/g;
+const WARNING_PATTERN = /\b(warn|warning|deprecated|postcss)\b/i;
+const STARTUP_READY_PATTERN = /\b(VITE\b.*ready|Local:\s+http:\/\/|Server listening on port)\b/i;
+
+function createLaunchId() {
+  return crypto.randomBytes(15).toString("base64url");
+}
+
+function stripAnsi(value) {
+  return value.replace(ANSI_PATTERN, "").replace(/\r/g, "");
+}
+
+function redactSecrets(value) {
+  return value
+    .replace(/(Authorization:\s*)(.+)$/gi, "$1[REDACTED]")
+    .replace(/\bBearer\s+[A-Za-z0-9._-]+\b/g, "Bearer [REDACTED]")
+    .replace(/([?&](?:api[_-]?key|token|access[_-]?token|session|cookie)=)([^&\s]+)/gi, "$1[REDACTED]")
+    .replace(/((?:api[_-]?key|token|session|cookie)\s*[:=]\s*)(["']?)[^\s"']+\2/gi, "$1[REDACTED]")
+    .replace(
+      /\b((?:postgres(?:ql)?|mysql|mariadb|redis):\/\/[^:\s/]+:)([^@\s/]+)(@)/gi,
+      "$1[REDACTED]$3",
+    );
+}
+
+function sanitizePersistedLine(value) {
+  return redactSecrets(stripAnsi(value));
+}
+
+function inferLevel(text) {
+  if (/\b(error|fatal|exception|traceback|unhandled)\b/i.test(text)) return "error";
+  if (WARNING_PATTERN.test(text)) return "warning";
+  return "info";
+}
+
+function parsePortFromText(text) {
+  const localMatch = text.match(/Local:\s+http:\/\/[^:]+:(\d+)/i);
+  if (localMatch?.[1]) return Number(localMatch[1]);
+  const listenMatch = text.match(/Server listening on port (\d+)/i);
+  if (listenMatch?.[1]) return Number(listenMatch[1]);
+  return null;
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+async function appendWorkflowEvent(payload) {
+  await fs.mkdir(path.dirname(WORKFLOW_EVENT_LOG), { recursive: true });
+  await fs.appendFile(
+    WORKFLOW_EVENT_LOG,
+    `${JSON.stringify({
+      tsMs: Date.now(),
+      source: "wrapper",
+      ...payload,
+    })}\n`,
+    "utf8",
+  );
+}
+
+async function pruneOldRuns(processName, keep = 5) {
+  const historyDir = path.join(HISTORY_ROOT, processName);
+  let entries;
+  try {
+    entries = await fs.readdir(historyDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  const jsonEntries = await Promise.all(
+    entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+      .map(async (entry) => {
+        const absolutePath = path.join(historyDir, entry.name);
+        const stat = await fs.stat(absolutePath);
+        return {
+          absolutePath,
+          launchId: entry.name.slice(0, -".json".length),
+          mtimeMs: stat.mtimeMs,
+        };
+      }),
+  );
+
+  jsonEntries.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  for (const stale of jsonEntries.slice(keep)) {
+    await fs.rm(stale.absolutePath, { force: true });
+    await fs.rm(path.join(historyDir, `${stale.launchId}.log`), { force: true });
+  }
+}
+
+export async function startLoggedProcess({
+  processName,
+  mode,
+  command,
+  args,
+  cwd = ROOT_DIR,
+  env,
+  expectedPort = null,
+}) {
+  const launchId = createLaunchId();
+  const historyDir = path.join(HISTORY_ROOT, processName);
+  const currentLogPath = path.join(RUNTIME_ROOT, `${processName}.log`);
+  const currentMetadataPath = path.join(RUNTIME_ROOT, `${processName}.json`);
+  const historyLogPath = path.join(historyDir, `${launchId}.log`);
+  const historyMetadataPath = path.join(historyDir, `${launchId}.json`);
+
+  const metadata = {
+    schemaVersion: 2,
+    processName,
+    mode,
+    launchId,
+    command: [command, ...args],
+    cwd,
+    pid: null,
+    port: expectedPort,
+    status: "launching",
+    startedAtMs: Date.now(),
+    startupCompletedAtMs: null,
+    exitedAtMs: null,
+    exitCode: null,
+  };
+
+  const persistMetadata = async () => {
+    await writeJson(currentMetadataPath, metadata);
+    await writeJson(historyMetadataPath, metadata);
+  };
+
+  await fs.mkdir(historyDir, { recursive: true });
+  await fs.mkdir(RUNTIME_ROOT, { recursive: true });
+  await fs.writeFile(currentLogPath, "", "utf8");
+  await fs.writeFile(historyLogPath, "", "utf8");
+  await persistMetadata();
+  await appendWorkflowEvent({
+    event: "launch_requested",
+    processName,
+    launchId,
+    port: expectedPort,
+    status: "requested",
+    message: `${mode} launch requested`,
+  });
+
+  const child = spawn(command, args, {
+    cwd,
+    stdio: ["inherit", "pipe", "pipe"],
+    env,
+  });
+
+  metadata.pid = child.pid ?? null;
+  metadata.status = "running";
+  await persistMetadata();
+  await appendWorkflowEvent({
+    event: "launch_started",
+    processName,
+    launchId,
+    pid: metadata.pid,
+    port: expectedPort,
+    status: "running",
+    message: `${mode} launch started`,
+  });
+
+  const currentWriteStream = rawFs.createWriteStream(currentLogPath, { flags: "a" });
+  const historyWriteStream = rawFs.createWriteStream(historyLogPath, { flags: "a" });
+  const streamBuffers = {
+    stdout: "",
+    stderr: "",
+  };
+  let lineQueue = Promise.resolve();
+  let observedOutput = false;
+  let portReadyEmitted = false;
+  let startupCompleted = false;
+
+  const handleLine = async (stream, line) => {
+    const clean = sanitizePersistedLine(line);
+    if (!clean.trim()) return;
+
+    const record = `${new Date().toISOString()} ${stream} ${clean}\n`;
+    currentWriteStream.write(record);
+    historyWriteStream.write(record);
+
+    if (!observedOutput) {
+      observedOutput = true;
+      await appendWorkflowEvent({
+        event: "stdout_observed",
+        processName,
+        launchId,
+        pid: metadata.pid,
+        port: metadata.port,
+        status: "running",
+        message: `first ${stream} output observed`,
+      });
+    }
+
+    const detectedPort = parsePortFromText(clean) ?? metadata.port ?? expectedPort ?? null;
+    if (detectedPort && !portReadyEmitted && /Local:\s+http:\/\/|Server listening on port/i.test(clean)) {
+      portReadyEmitted = true;
+      if (!metadata.port) {
+        metadata.port = detectedPort;
+        await persistMetadata();
+      }
+      await appendWorkflowEvent({
+        event: "port_ready",
+        processName,
+        launchId,
+        pid: metadata.pid,
+        port: detectedPort,
+        status: "ready",
+        message: clean,
+      });
+    }
+
+    if (!startupCompleted && STARTUP_READY_PATTERN.test(clean)) {
+      startupCompleted = true;
+      metadata.startupCompletedAtMs = Date.now();
+      metadata.status = "ready";
+      await persistMetadata();
+      await appendWorkflowEvent({
+        event: "startup_completed",
+        processName,
+        launchId,
+        pid: metadata.pid,
+        port: metadata.port,
+        status: "ready",
+        message: clean,
+      });
+    }
+
+    if (inferLevel(clean) !== "info") {
+      await appendWorkflowEvent({
+        event: "warning_detected",
+        processName,
+        launchId,
+        pid: metadata.pid,
+        port: metadata.port,
+        status: inferLevel(clean),
+        message: clean,
+      });
+    }
+  };
+
+  const enqueueLines = (stream, chunk, target) => {
+    target.write(chunk);
+    streamBuffers[stream] += chunk.toString("utf8");
+    const parts = streamBuffers[stream].split(/\n/);
+    streamBuffers[stream] = parts.pop() ?? "";
+    for (const part of parts) {
+      const normalized = part.replace(/\r/g, "");
+      lineQueue = lineQueue.then(() => handleLine(stream, normalized));
+    }
+  };
+
+  child.stdout.on("data", (chunk) => enqueueLines("stdout", chunk, process.stdout));
+  child.stderr.on("data", (chunk) => enqueueLines("stderr", chunk, process.stderr));
+
+  const flushBufferedLines = () => {
+    for (const [stream, value] of Object.entries(streamBuffers)) {
+      const normalized = value.replace(/\r/g, "").trimEnd();
+      if (!normalized) continue;
+      lineQueue = lineQueue.then(() => handleLine(stream, normalized));
+      streamBuffers[stream] = "";
+    }
+  };
+
+  child.on("close", async (code) => {
+    flushBufferedLines();
+    await lineQueue;
+    currentWriteStream.end();
+    historyWriteStream.end();
+    metadata.exitedAtMs = Date.now();
+    metadata.exitCode = code ?? 0;
+    metadata.status = (code ?? 0) === 0 ? "exited" : "failed";
+    await persistMetadata();
+    await appendWorkflowEvent({
+      event: "process_exit",
+      processName,
+      launchId,
+      pid: metadata.pid,
+      port: metadata.port,
+      status: metadata.status,
+      message: `${mode} process exited with code ${code ?? 0}`,
+    });
+    await pruneOldRuns(processName);
+    process.exit(code ?? 0);
+  });
+
+  child.on("error", async (error) => {
+    console.error(`[imagicma] 启动 ${mode} 失败：${error.message}`);
+    metadata.exitedAtMs = Date.now();
+    metadata.status = "failed";
+    await persistMetadata();
+    await appendWorkflowEvent({
+      event: "process_exit",
+      processName,
+      launchId,
+      pid: metadata.pid,
+      port: metadata.port,
+      status: "failed",
+      message: error.message,
+    });
+    process.exit(1);
+  });
+
+  return child;
+}

package/template-hono/scripts/imagicma-start.mjs

@@ -1,24 +1,18 @@
-import { spawn } from "node:child_process";
 import path from "node:path";
 import { ROOT_DIR } from "./imagicma-common.mjs";
+import { startLoggedProcess } from "./imagicma-runtime-logs.mjs";
 
 const entry = path.join(ROOT_DIR, "dist", "server", "index.js");
 
-const child = spawn(process.execPath, [entry], {
+await startLoggedProcess({
+  processName: "web",
+  mode: "start",
+  command: process.execPath,
+  args: [entry],
   cwd: ROOT_DIR,
-  stdio: "inherit",
   env: {
     ...process.env,
     IMAGICMA_SCRIPT_LAUNCH: "1",
     IMAGICMA_LAUNCH_MODE: "start",
   },
 });
-
-child.on("close", (code) => {
-  process.exit(code ?? 0);
-});
-
-child.on("error", (error) => {
-  console.error(`[imagicma] 启动 start 失败：${error.message}`);
-  process.exit(1);
-});

package/template-hono/server/database-path.ts

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const DEFAULT_DATABASE_FILE = "./.data/app.db";
+
+export function resolveDatabaseFilePath() {
+  const configuredPath = process.env.DATABASE_FILE?.trim();
+  const targetPath =
+    configuredPath && configuredPath.length > 0 ? configuredPath : DEFAULT_DATABASE_FILE;
+
+  return path.resolve(process.cwd(), targetPath);
+}
+
+export function ensureDatabaseFilePath() {
+  const databaseFilePath = resolveDatabaseFilePath();
+
+  fs.mkdirSync(path.dirname(databaseFilePath), { recursive: true });
+
+  return databaseFilePath;
+}
+
+export function resolveDatabaseUrl(databaseFilePath = resolveDatabaseFilePath()) {
+  return pathToFileURL(databaseFilePath).href;
+}
+
+export function ensureDatabaseUrl() {
+  const databaseFilePath = ensureDatabaseFilePath();
+
+  return resolveDatabaseUrl(databaseFilePath);
+}
+
+export function describeDatabaseFilePath(databaseFilePath = resolveDatabaseFilePath()) {
+  return path.relative(process.cwd(), databaseFilePath) || path.basename(databaseFilePath);
+}

package/template-hono/server/db.ts

@@ -1,22 +1,20 @@
-import { drizzle } from "drizzle-orm/node-postgres";
-import pg from "pg";
+import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
 import * as schema from "../shared/schema";
+import { ensureDatabaseUrl } from "./database-path";
 
-const { Pool } = pg;
-
-const databaseUrl = process.env.DATABASE_URL;
+const databaseUrl = ensureDatabaseUrl();
+type DatabaseClient = ReturnType<typeof createClient>;
 
 declare global {
-  var __dbPool: InstanceType<typeof Pool> | undefined;
+  var __dbClient: DatabaseClient | undefined;
 }
 
-export const pool =
-  databaseUrl
-    ? globalThis.__dbPool ?? new Pool({ connectionString: databaseUrl })
-    : undefined;
+const sqlite = globalThis.__dbClient ?? createClient({ url: databaseUrl });
 
-if (databaseUrl && process.env.NODE_ENV !== "production") {
-  globalThis.__dbPool = pool;
+if (process.env.NODE_ENV !== "production") {
+  globalThis.__dbClient = sqlite;
 }
 
-export const db = pool ? drizzle(pool, { schema }) : undefined;
+export const db = drizzle(sqlite, { schema });
+export { databaseUrl };

package/template-hono/server/storage.ts

@@ -1,5 +1,6 @@
 import { desc } from "drizzle-orm";
 import { messages } from "../shared/schema";
+import { describeDatabaseFilePath } from "./database-path";
 import { db } from "./db";
 
 export interface IStorage {
@@ -8,12 +9,6 @@ export interface IStorage {
 
 export class DatabaseStorage implements IStorage {
   async getMessage(): Promise<string> {
-    if (!db) {
-      throw new Error(
-        "DATABASE_URL 未设置：请在 .env.local 中配置 Postgres 连接串，然后执行 `npm run db:push`。",
-      );
-    }
-
     try {
       const rows = await db
         .select({ content: messages.content })
@@ -25,12 +20,8 @@ export class DatabaseStorage implements IStorage {
     } catch (error) {
       console.error("DatabaseStorage.getMessage() failed:", error);
 
-      if (error instanceof Error && error.message.includes("DATABASE_URL")) {
-        throw error;
-      }
-
       throw new Error(
-        "数据库读取失败：请确认已设置 DATABASE_URL，并先执行 `npm run db:push` 创建表结构。",
+        `数据库读取失败：请先执行 \`pnpm db:push\` 初始化 SQLite 数据库（${describeDatabaseFilePath()}）。`,
       );
     }
   }

package/template-hono/shared/schema.ts

@@ -1,11 +1,11 @@
-import { pgTable, text, serial, boolean } from "drizzle-orm/pg-core";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 import { createInsertSchema } from "drizzle-zod";
 import { z } from "zod";
 
-export const messages = pgTable("messages", {
-  id: serial("id").primaryKey(),
+export const messages = sqliteTable("messages", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
   content: text("content").notNull(),
-  isRead: boolean("is_read").default(false),
+  isRead: integer("is_read", { mode: "boolean" }).notNull().default(false),
 });
 
 export const insertMessageSchema = createInsertSchema(messages).pick({

package/template-hono/tests/e2e/fixtures/imagicma.ts

@@ -0,0 +1,70 @@
+import { test as base, expect } from "@playwright/test";
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// When run_test drives Playwright, it injects these env vars so fixtures can write
+// browser/network/page-error evidence directly into .imagicma/runtime/run-test/<runId>/.
+const runtimeRoot = process.env.IMAGICMA_RUN_TEST_RUNTIME_ROOT;
+const runId = process.env.IMAGICMA_RUN_ID || "manual";
+const failureResourceTypes = new Set(["document", "xhr", "fetch"]);
+
+function appendJsonl(name: string, row: Record<string, unknown>): void {
+  if (!runtimeRoot) return;
+  appendFileSync(join(runtimeRoot, name), `${JSON.stringify(row)}\n`, "utf-8");
+}
+
+export const test = base.extend({
+  page: async ({ page }, use) => {
+    if (runtimeRoot) {
+      mkdirSync(join(runtimeRoot, "screenshots"), { recursive: true });
+      mkdirSync(join(runtimeRoot, "traces"), { recursive: true });
+      mkdirSync(join(runtimeRoot, "videos"), { recursive: true });
+      page.on("console", (message) => {
+        const type = message.type();
+        if (type !== "warning" && type !== "warn" && type !== "error") return;
+        appendJsonl("console-events.jsonl", {
+          tsMs: Date.now(),
+          runId,
+          type,
+          text: message.text(),
+        });
+      });
+      page.on("pageerror", (error) => appendJsonl("page-errors.jsonl", {
+        tsMs: Date.now(),
+        runId,
+        message: error.message,
+      }));
+      page.on("response", async (response) => {
+        const status = response.status();
+        const resourceType = response.request().resourceType();
+        if (status < 400 || !failureResourceTypes.has(resourceType)) return;
+        appendJsonl("network-failures.jsonl", {
+          tsMs: Date.now(),
+          runId,
+          url: response.url(),
+          method: response.request().method(),
+          status,
+          errorText: null,
+          resourceType,
+        });
+      });
+      page.on("requestfailed", (request) => appendJsonl("network-failures.jsonl", {
+        tsMs: Date.now(),
+        runId,
+        url: request.url(),
+        method: request.method(),
+        status: null,
+        errorText: request.failure()?.errorText ?? "requestfailed",
+        resourceType: request.resourceType(),
+      }));
+    }
+
+    await use(page);
+
+    if (runtimeRoot) {
+      writeFileSync(join(runtimeRoot, "current-url.txt"), page.url(), "utf-8");
+    }
+  },
+});
+
+export { expect };

package/template-hono/types/pg.d.ts

@@ -1,19 +0,0 @@
-declare module "pg" {
-  export type PoolConfig = {
-    connectionString?: string;
-    [key: string]: unknown;
-  };
-
-  export class Pool {
-    constructor(config?: PoolConfig);
-    query: (...args: unknown[]) => Promise<unknown>;
-    end: () => Promise<void>;
-  }
-
-  const pg: {
-    Pool: typeof Pool;
-  };
-
-  export default pg;
-}
-