@lark-apaas/fullstack-cli 1.1.16-beta.5 → 1.1.16-beta.7

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs25 from "fs";
-import path21 from "path";
+import fs26 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -1041,6 +1041,8 @@ async function fetchColumnComments(connectionString, options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const url = new URL(connectionString);
   const schemaName = url.searchParams.get("schema") ?? "public";
+  const start = Date.now();
+  console.log(`[fetchColumnComments] \u2192 Querying pg_description for schema=${schemaName} (timeout=${timeoutMs}ms)`);
   const sql = postgres(connectionString, {
     connect_timeout: Math.ceil(timeoutMs / 1e3),
     idle_timeout: Math.ceil(timeoutMs / 1e3)
@@ -1069,6 +1071,7 @@ async function fetchColumnComments(connectionString, options = {}) {
       const key = `${row.tableName}.${row.columnName}`;
       commentMap.set(key, row.comment);
     }
+    console.log(`[fetchColumnComments] \u2190 Fetched ${commentMap.size} column comments (${Date.now() - start}ms)`);
     return commentMap;
   } finally {
     await sql.end().catch(() => {
@@ -1167,6 +1170,79 @@ function addJsonbTypeComments(source, columnComments) {
   return { text: result.join("\n"), added };
 }
 
+// src/commands/db/gen-dbschema/transforms/text/synced-table-comments.ts
+var TABLE_COMMENT = "Synced table: data is auto-synced from external source. Do not rename or delete this table.";
+var FIELD_COMMENT = "Synced field: auto-synced, do not modify or delete";
+var TABLE_DEF_REGEX = /^(export const\s+\w+\s*=\s*(?:pgTable|pgView|pgMaterializedView)\(\s*["'`])([^"'`]+)(["'`])/;
+var FIELD_WITH_NAME_REGEX = /^\s*[\w"']+\s*:\s*\w+\(\s*["'`]([^"'`]+)["'`]/;
+var FIELD_PROP_NAME_REGEX = /^\s*([\w]+)\s*:/;
+function addSyncedTableComments(source, syncedTableMap) {
+  if (!syncedTableMap || syncedTableMap.size === 0) {
+    return { text: source, added: 0 };
+  }
+  const lines = source.split("\n");
+  const result = [];
+  let added = 0;
+  let currentSyncedFields = null;
+  let insideTableBody = false;
+  let braceDepth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const tableMatch = line.match(TABLE_DEF_REGEX);
+    if (tableMatch) {
+      const tableName = tableMatch[2];
+      const syncedFields = syncedTableMap.get(tableName);
+      if (syncedFields) {
+        currentSyncedFields = syncedFields;
+        insideTableBody = true;
+        braceDepth = 0;
+        const prevLine = result[result.length - 1]?.trim() ?? "";
+        if (!prevLine.includes("Synced table")) {
+          const indentMatch = line.match(/^\s*/);
+          const indent = indentMatch ? indentMatch[0] : "";
+          result.push(`${indent}// ${TABLE_COMMENT}`);
+          added++;
+        }
+      }
+    }
+    if (insideTableBody) {
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        insideTableBody = false;
+        currentSyncedFields = null;
+      }
+      if (currentSyncedFields && braceDepth >= 1 && !tableMatch) {
+        const columnName = extractColumnName2(line);
+        if (columnName && currentSyncedFields.has(columnName)) {
+          const prevLine = result[result.length - 1]?.trim() ?? "";
+          if (!prevLine.includes("Synced field")) {
+            const indentMatch = line.match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0] : "";
+            result.push(`${indent}// ${FIELD_COMMENT}`);
+            added++;
+          }
+        }
+      }
+    }
+    result.push(line);
+  }
+  return { text: result.join("\n"), added };
+}
+function extractColumnName2(line) {
+  const withNameMatch = line.match(FIELD_WITH_NAME_REGEX);
+  if (withNameMatch) {
+    return withNameMatch[1];
+  }
+  const propMatch = line.match(FIELD_PROP_NAME_REGEX);
+  if (propMatch) {
+    return propMatch[1];
+  }
+  return null;
+}
+
 // src/commands/db/gen-dbschema/transforms/text/table-aliases.ts
 var TABLE_ALIAS_MARKER = "// table aliases";
 function generateTableAliases(source) {
@@ -1215,13 +1291,16 @@ function postprocessSchema(rawSource, options = {}) {
   source = inlineCustomTypes(source);
   const jsonbCommentsResult = addJsonbTypeComments(source, options.columnComments);
   source = jsonbCommentsResult.text;
+  const syncedCommentsResult = addSyncedTableComments(source, options.syncedTableMap);
+  source = syncedCommentsResult.text;
   source = generateTableAliases(source);
   source = formatSource(source);
   return {
     source,
     astStats,
     patchedDefects: patchResult.fixed,
-    addedJsonbComments: jsonbCommentsResult.added
+    addedJsonbComments: jsonbCommentsResult.added,
+    addedSyncedComments: syncedCommentsResult.added
   };
 }
 function logStats(result, prefix = "[postprocess]") {
@@ -1271,6 +1350,9 @@ function logStats(result, prefix = "[postprocess]") {
   if (result.addedJsonbComments > 0) {
     console.info(`${prefix} Added ${result.addedJsonbComments} JSDoc comments for jsonb fields`);
   }
+  if (result.addedSyncedComments > 0) {
+    console.info(`${prefix} Added ${result.addedSyncedComments} comments for synced tables/fields`);
+  }
 }
 
 // src/commands/db/gen-dbschema/index.ts
@@ -1281,7 +1363,10 @@ async function postprocessDrizzleSchema(targetPath, options = {}) {
     return void 0;
   }
   const rawSource = fs3.readFileSync(resolvedPath, "utf8");
-  const result = postprocessSchema(rawSource, { columnComments: options.columnComments });
+  const result = postprocessSchema(rawSource, {
+    columnComments: options.columnComments,
+    syncedTableMap: options.syncedTableMap
+  });
   fs3.writeFileSync(resolvedPath, result.source, "utf8");
   logStats(result, "[postprocess-drizzle-schema]");
   return {
@@ -1291,10 +1376,112 @@ async function postprocessDrizzleSchema(targetPath, options = {}) {
     patchedDefects: result.patchedDefects,
     replacedTimestamps: result.astStats.replacedTimestamp,
     replacedDefaultNow: result.astStats.replacedDefaultNow,
-    addedJsonbComments: result.addedJsonbComments
+    addedJsonbComments: result.addedJsonbComments,
+    addedSyncedComments: result.addedSyncedComments
   };
 }
 
+// src/utils/http-client.ts
+import { HttpClient } from "@lark-apaas/http-client";
+var clientInstance = null;
+function getHttpClient() {
+  if (!clientInstance) {
+    clientInstance = new HttpClient({
+      timeout: 3e4,
+      platform: {
+        enabled: true
+      }
+    });
+    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
+    if (canaryEnv) {
+      clientInstance.interceptors.request.use((req) => {
+        req.headers["x-tt-env"] = canaryEnv;
+        return req;
+      });
+    }
+  }
+  return clientInstance;
+}
+
+// src/commands/db/gen-dbschema/utils/fetch-synced-tables.ts
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+async function fetchSyncedTables(appId, workspace) {
+  try {
+    const client = getHttpClient();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Timeout after ${DEFAULT_TIMEOUT_MS2}ms`)),
+        DEFAULT_TIMEOUT_MS2
+      );
+    });
+    const start = Date.now();
+    console.log(
+      `[fetchSyncedTables] \u2192 GET listTableView (dbBranch=main) appId=${appId ? "set" : "unset"} workspace=${workspace ? "set" : "unset"}`
+    );
+    const response = await Promise.race([
+      client.get(
+        `/api/v1/dataloom/inner/app/${appId}/workspaces/${workspace}/listTableView`,
+        { params: { dbBranch: "main" }, headers: { "x-supaas-bizsource": "miaoda" } }
+      ),
+      timeoutPromise
+    ]);
+    console.log(
+      `[fetchSyncedTables] \u2190 listTableView response: ${response.status} ${response.statusText} (${Date.now() - start}ms) with logId=${response.headers.get("x-tt-logid")}`
+    );
+    if (!response.ok) {
+      throw new Error(
+        `listTableView API failed: ${response.status} ${response.statusText}`
+      );
+    }
+    let json;
+    try {
+      json = await response.json();
+    } catch (error) {
+      console.warn(
+        "[fetchSyncedTables] \u26A0 Failed to parse listTableView response JSON, returning empty map:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    const tableView = json?.data?.data;
+    if (!tableView) {
+      console.warn(
+        "[fetchSyncedTables] \u26A0 listTableView response missing data.data, returning empty map"
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    const syncedMap = extractSyncedTableMap(tableView);
+    const totalCount = (tableView.table?.data?.length ?? 0) + (tableView.view?.data?.length ?? 0) + (tableView.materializedView?.data?.length ?? 0);
+    console.log(
+      `[fetchSyncedTables] \u2713 Extracted synced tables: ${syncedMap.size}/${totalCount} (elapsed ${Date.now() - start}ms)`
+    );
+    return syncedMap;
+  } catch (error) {
+    console.error(
+      "[fetchSyncedTables] \u274C Error fetching synced tables:",
+      error
+    );
+    return /* @__PURE__ */ new Map();
+  }
+}
+function extractSyncedTableMap(tableView) {
+  const syncedMap = /* @__PURE__ */ new Map();
+  const allTables = [
+    ...tableView.table?.data ?? [],
+    ...tableView.view?.data ?? [],
+    ...tableView.materializedView?.data ?? []
+  ];
+  for (const table of allTables) {
+    if (table.bitableSyncTask && table.bitableSyncTask.fieldApiNameList?.length > 0) {
+      syncedMap.set(
+        table.tableName,
+        new Set(table.bitableSyncTask.fieldApiNameList)
+      );
+    }
+  }
+  return syncedMap;
+}
+
 // src/commands/db/gen-nest-resource/generator.ts
 import { pluralize } from "inflection";
 
@@ -1973,7 +2160,9 @@ async function run(options = {}) {
   }
   const databaseUrl = process.env.SUDA_DATABASE_URL;
   if (!databaseUrl) {
-    console.error("[gen-db-schema] Error: SUDA_DATABASE_URL environment variable is required");
+    console.error(
+      "[gen-db-schema] Error: SUDA_DATABASE_URL environment variable is required"
+    );
     process.exit(1);
   }
   const outputPath = options.output || process.env.DB_SCHEMA_OUTPUT || "server/database/schema.ts";
@@ -1988,9 +2177,14 @@ async function run(options = {}) {
     path2.resolve(__dirname2, "../../../dist/config/drizzle.config.js")
   ];
   const configPath = configPathCandidates.find((p) => fs4.existsSync(p));
-  console.log("[gen-db-schema] Using drizzle config from:", configPath ?? "(not found)");
+  console.log(
+    "[gen-db-schema] Using drizzle config from:",
+    configPath ?? "(not found)"
+  );
   if (!configPath) {
-    console.error("[gen-db-schema] Error: drizzle config not found in CLI package");
+    console.error(
+      "[gen-db-schema] Error: drizzle config not found in CLI package"
+    );
     process.exit(1);
   }
   const resolveDrizzleKitBin = () => {
@@ -2006,7 +2200,9 @@ async function run(options = {}) {
           const binField = pkgJson.bin;
           const binRelPath = typeof binField === "string" ? binField : binField?.["drizzle-kit"];
           if (!binRelPath) {
-            throw new Error("Unable to resolve drizzle-kit binary from package.json");
+            throw new Error(
+              "Unable to resolve drizzle-kit binary from package.json"
+            );
           }
           return path2.resolve(currentDir, binRelPath);
         }
@@ -2017,14 +2213,65 @@ async function run(options = {}) {
     throw new Error("Unable to locate drizzle-kit package root");
   };
   let columnComments;
-  try {
-    columnComments = await fetchColumnComments(databaseUrl, { timeoutMs: 1e4 });
-    console.log(`[gen-db-schema] \u2713 Fetched ${columnComments.size} column comments`);
-  } catch (err) {
+  let syncedTableMap;
+  const appId = process.env.app_id;
+  const workspace = process.env.suda_workspace_id;
+  console.log(
+    `[gen-db-schema] Pre-fetch info: columnComments=enabled, syncedTables=${appId && workspace ? "enabled" : "skipped"} (app_id=${appId ? "set" : "unset"}, suda_workspace_id=${workspace ? "set" : "unset"})`
+  );
+  const columnCommentsTask = (async () => {
+    const start = Date.now();
+    console.log("[gen-db-schema] \u2192 Fetching column comments...");
+    const res = await fetchColumnComments(databaseUrl, { timeoutMs: 1e4 });
+    console.log(
+      `[gen-db-schema] \u2190 Fetched column comments: ${res.size} items (${Date.now() - start}ms)`
+    );
+    return res;
+  })();
+  const syncedTablesTask = appId && workspace ? (async () => {
+    const start = Date.now();
+    console.log(
+      "[gen-db-schema] \u2192 Fetching synced tables from listTableView..."
+    );
+    const res = await fetchSyncedTables(appId, workspace);
+    console.log(
+      `[gen-db-schema] \u2190 Fetched synced tables: ${res.size} tables (${Date.now() - start}ms)`
+    );
+    return res;
+  })() : void 0;
+  const fetchTasks = await Promise.allSettled([
+    columnCommentsTask,
+    ...syncedTablesTask ? [syncedTablesTask] : []
+  ]);
+  if (fetchTasks[0].status === "fulfilled") {
+    columnComments = fetchTasks[0].value;
+    console.log(
+      `[gen-db-schema] \u2713 Column comments ready: ${columnComments.size}`
+    );
+  } else {
     console.warn(
       "[gen-db-schema] \u26A0 Failed to fetch column comments (skipping):",
-      err instanceof Error ? err.message : String(err)
+      fetchTasks[0].reason instanceof Error ? fetchTasks[0].reason.message : String(fetchTasks[0].reason)
+    );
+  }
+  if (appId && workspace) {
+    if (fetchTasks[1]?.status === "fulfilled") {
+      syncedTableMap = fetchTasks[1].value;
+      console.log(
+        `[gen-db-schema] \u2713 Synced tables ready: ${syncedTableMap.size}`
+      );
+    } else if (fetchTasks[1]?.status === "rejected") {
+      console.warn(
+        "[gen-db-schema] \u26A0 Failed to fetch synced tables (skipping):",
+        fetchTasks[1].reason instanceof Error ? fetchTasks[1].reason.message : String(fetchTasks[1].reason)
+      );
+      syncedTableMap = /* @__PURE__ */ new Map();
+    }
+  } else {
+    console.info(
+      "[gen-db-schema] \u2139 Skipping synced table detection (app_id or suda_workspace_id not set)"
     );
+    syncedTableMap = /* @__PURE__ */ new Map();
   }
   try {
     const env = {
@@ -2036,13 +2283,19 @@ async function run(options = {}) {
     };
     const drizzleKitBin = resolveDrizzleKitBin();
     const spawnArgs = [drizzleKitBin, "introspect", "--config", configPath];
-    const result = spawnSync(process.execPath, spawnArgs, { stdio: "inherit", env, cwd: process.cwd() });
+    const result = spawnSync(process.execPath, spawnArgs, {
+      stdio: "inherit",
+      env,
+      cwd: process.cwd()
+    });
     if (result.error) {
       console.error("[gen-db-schema] Execution failed:", result.error);
       throw result.error;
     }
     if ((result.status ?? 0) !== 0) {
-      throw new Error(`drizzle-kit introspect failed with status ${result.status}`);
+      throw new Error(
+        `drizzle-kit introspect failed with status ${result.status}`
+      );
     }
     const generatedSchema = path2.join(OUT_DIR, "schema.ts");
     if (!fs4.existsSync(generatedSchema)) {
@@ -2050,10 +2303,14 @@ async function run(options = {}) {
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
     const stats = await postprocessDrizzleSchema(generatedSchema, {
-      columnComments
+      columnComments,
+      syncedTableMap
     });
     if (stats?.unmatchedUnknown?.length) {
-      console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
+      console.warn(
+        "[gen-db-schema] Unmatched custom types detected:",
+        stats.unmatchedUnknown
+      );
     }
     console.log("[gen-db-schema] \u2713 Postprocessed schema");
     fs4.mkdirSync(path2.dirname(SCHEMA_FILE), { recursive: true });
@@ -2068,14 +2325,22 @@ async function run(options = {}) {
           schemaFilePath,
           moduleOutputDir: path2.resolve(process.cwd(), "server/modules")
         });
-        console.log("[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully");
+        console.log(
+          "[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully"
+        );
       }
     } catch (error) {
-      console.warn("[gen-db-schema] Generate NestJS Module Boilerplate failed:", error instanceof Error ? error.message : String(error));
+      console.warn(
+        "[gen-db-schema] Generate NestJS Module Boilerplate failed:",
+        error instanceof Error ? error.message : String(error)
+      );
     }
     console.log("[gen-db-schema] \u2713 Complete");
   } catch (err) {
-    console.error("[gen-db-schema] Failed:", err instanceof Error ? err.message : String(err));
+    console.error(
+      "[gen-db-schema] Failed:",
+      err instanceof Error ? err.message : String(err)
+    );
     exitCode = 1;
   } finally {
     if (fs4.existsSync(OUT_DIR)) {
@@ -2162,6 +2427,13 @@ var syncConfig = {
       type: "add-line",
       to: ".gitignore",
       line: ".agent/"
+    },
+    // 8. 同步 .spark_project 配置文件（总是覆盖）
+    {
+      from: "templates/.spark_project",
+      to: ".spark_project",
+      type: "file",
+      overwrite: true
     }
   ],
   // 文件权限设置
@@ -2419,28 +2691,6 @@ var syncCommand = {
   }
 };
 
-// src/utils/http-client.ts
-import { HttpClient } from "@lark-apaas/http-client";
-var clientInstance = null;
-function getHttpClient() {
-  if (!clientInstance) {
-    clientInstance = new HttpClient({
-      timeout: 3e4,
-      platform: {
-        enabled: true
-      }
-    });
-    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
-    if (canaryEnv) {
-      clientInstance.interceptors.request.use((req) => {
-        req.headers["x-tt-env"] = canaryEnv;
-        return req;
-      });
-    }
-  }
-  return clientInstance;
-}
-
 // src/utils/telemetry.ts
 async function reportEvents(events) {
   if (events.length === 0) {
@@ -2595,7 +2845,7 @@ function autoCommitUpgradeChanges(version, cwd, filesToStage, commitMessage) {
 - Cleanup package.json config
 - Upgrade @lark-apaas dependencies (if any)
 
-Auto-committed by fullstack-cli v${version}`;
+Auto-committed by fullstack-cli`;
     gitCommit(message, cwd);
     console.log(`[fullstack-cli] \u2713 Auto-committed ${changedFiles.length} changed file(s)`);
     return true;
@@ -4042,7 +4292,7 @@ var PROMPT_PATTERNS = [
   { pattern: /proceed\?/i, answer: "y\n" }
 ];
 async function executeShadcnAdd(registryItemPath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let output = "";
     const args = ["--yes", "shadcn@3.8.2", "add", registryItemPath];
     const ptyProcess = pty.spawn("npx", args, {
@@ -4068,7 +4318,7 @@ async function executeShadcnAdd(registryItemPath) {
     });
     const timeoutId = setTimeout(() => {
       ptyProcess.kill();
-      resolve({
+      resolve2({
         success: false,
         files: [],
         error: "\u6267\u884C\u8D85\u65F6"
@@ -4079,7 +4329,7 @@ async function executeShadcnAdd(registryItemPath) {
       const success = exitCode === 0;
       const filePaths = parseOutput(output);
       const files = filePaths.map(toFileInfo);
-      resolve({
+      resolve2({
         success,
         files,
         error: success ? void 0 : output || `Process exited with code ${exitCode}`
@@ -4090,12 +4340,12 @@ async function executeShadcnAdd(registryItemPath) {
 
 // src/commands/component/add.handler.ts
 function runActionPluginInit() {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     execFile("fullstack-cli", ["action-plugin", "init"], { cwd: process.cwd(), stdio: "ignore" }, (error) => {
       if (error) {
         debug("action-plugin init \u5931\u8D25: %s", error.message);
       }
-      resolve();
+      resolve2();
     });
   });
 }
@@ -6931,7 +7181,45 @@ async function genArtifactUploadCredential(appId, body) {
   const response = await client.post(url, body);
   if (!response.ok || response.status !== 200) {
     throw new Error(
-      `API request failed: ${response.status} ${response.statusText}`
+      `gen_artifact_upload_credential \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function getDefaultBucketId(appId) {
+  const client = getHttpClient();
+  const url = `/b/${appId}/get_published_v2`;
+  const response = await client.get(url);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `get_published_v2 \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  const bucketId = data?.data?.app_runtime_extra?.bucket?.default_bucket_id;
+  if (!bucketId) {
+    throw new Error(`\u672A\u627E\u5230\u5E94\u7528 ${appId} \u7684\u9ED8\u8BA4\u5B58\u50A8\u6876`);
+  }
+  return bucketId;
+}
+async function preUploadStaticAttachment(appId, bucketId) {
+  const client = getHttpClient();
+  const url = `/v1/app/${appId}/storage/bucket/${bucketId}/preUploadStatic`;
+  const response = await client.post(url, {});
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `preUploadStatic \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function uploadStaticAttachmentCallback(appId, bucketId, body) {
+  const client = getHttpClient();
+  const url = `/v1/app/${appId}/storage/bucket/${bucketId}/object/callbackStatic`;
+  const response = await client.post(url, body);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `callbackStatic \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
     );
   }
   return response.json();
@@ -6969,6 +7257,170 @@ function camelToKebab(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 
+// src/commands/build/upload-static.handler.ts
+import * as fs25 from "fs";
+import * as path21 from "path";
+import { execFileSync } from "child_process";
+function readCredentialsFromEnv() {
+  const uploadPrefix = process.env.STATIC_UPLOAD_PREFIX;
+  const uploadID = process.env.STATIC_UPLOAD_ID;
+  const bucketId = process.env.STATIC_UPLOAD_BUCKET_ID;
+  const accessKeyID = process.env.STATIC_UPLOAD_AK;
+  const secretAccessKey = process.env.STATIC_UPLOAD_SK;
+  const sessionToken = process.env.STATIC_UPLOAD_TOKEN;
+  if (!uploadPrefix || !uploadID || !bucketId || !accessKeyID || !secretAccessKey || !sessionToken) {
+    return null;
+  }
+  return { uploadPrefix, uploadID, bucketId, accessKeyID, secretAccessKey, sessionToken };
+}
+var LOG_PREFIX = "[upload-static]";
+async function uploadStatic(options) {
+  try {
+    const {
+      appId,
+      staticDir = "shared/static",
+      tosutilPath = "/workspace/tosutil",
+      endpoint = "tos-cn-beijing.volces.com",
+      region = "cn-beijing"
+    } = options;
+    const resolvedStaticDir = path21.resolve(staticDir);
+    if (!fs25.existsSync(resolvedStaticDir)) {
+      console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E0D\u5B58\u5728: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
+      return;
+    }
+    if (isDirEmpty(resolvedStaticDir)) {
+      console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E3A\u7A7A: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
+      return;
+    }
+    if (!fs25.existsSync(tosutilPath)) {
+      throw new Error(
+        `tosutil \u4E0D\u5B58\u5728: ${tosutilPath}\u3002\u8BF7\u786E\u4FDD\u6D41\u6C34\u7EBF\u5DF2\u5728"\u4EA7\u7269\u6253\u5305\u4E0A\u4F20"\u6B65\u9AA4\u4E2D\u4E0B\u8F7D tosutil\u3002`
+      );
+    }
+    let uploadPrefix;
+    let uploadID;
+    let bucketId;
+    let accessKeyID;
+    let secretAccessKey;
+    let sessionToken;
+    const envCredentials = readCredentialsFromEnv();
+    if (envCredentials) {
+      console.error(`${LOG_PREFIX} \u4F7F\u7528\u73AF\u5883\u53D8\u91CF\u4E2D\u7684\u4E0A\u4F20\u51ED\u8BC1`);
+      ({ uploadPrefix, uploadID, bucketId, accessKeyID, secretAccessKey, sessionToken } = envCredentials);
+    } else {
+      console.error(`${LOG_PREFIX} \u73AF\u5883\u53D8\u91CF\u672A\u8BBE\u7F6E\uFF0C\u8C03\u7528 preUploadStatic...`);
+      bucketId = await resolveBucketId(appId);
+      const preUploadResp = await fetchPreUpload(appId, bucketId);
+      const { uploadCredential } = preUploadResp.data;
+      ({ uploadPrefix, uploadID } = preUploadResp.data);
+      ({ AccessKeyID: accessKeyID, SecretAccessKey: secretAccessKey, SessionToken: sessionToken } = uploadCredential);
+    }
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20\u76EE\u6807: ${uploadPrefix}`);
+    console.error(`${LOG_PREFIX} \u914D\u7F6E tosutil...`);
+    configureTosutil(tosutilPath, {
+      endpoint,
+      region,
+      accessKeyID,
+      secretAccessKey,
+      sessionToken
+    });
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20 ${resolvedStaticDir} -> ${uploadPrefix}`);
+    uploadToTos(tosutilPath, resolvedStaticDir, uploadPrefix);
+    console.error(`${LOG_PREFIX} tosutil \u4E0A\u4F20\u5B8C\u6210`);
+    console.error(`${LOG_PREFIX} \u8C03\u7528 callbackStatic (uploadID: ${uploadID})...`);
+    const callbackResp = await uploadStaticAttachmentCallback(appId, bucketId, { uploadID });
+    if (callbackResp.status_code !== "0") {
+      throw new Error(`callbackStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${callbackResp.status_code}`);
+    }
+    const attachments = callbackResp.data?.attachments || [];
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20\u5B8C\u6210\uFF0C\u5171 ${attachments.length} \u4E2A\u6587\u4EF6`);
+    console.log(JSON.stringify(callbackResp));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${LOG_PREFIX} Error: ${message}`);
+    process.exit(1);
+  }
+}
+async function fetchPreUpload(appId, bucketId) {
+  const response = await preUploadStaticAttachment(appId, bucketId);
+  if (response.status_code !== "0") {
+    throw new Error(`preUploadStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${response.status_code}`);
+  }
+  const { uploadPrefix, uploadID, uploadCredential } = response.data || {};
+  if (!uploadPrefix || !uploadID) {
+    throw new Error("preUploadStatic \u8FD4\u56DE\u6570\u636E\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11 uploadPrefix \u6216 uploadID");
+  }
+  if (!uploadCredential?.AccessKeyID || !uploadCredential?.SecretAccessKey || !uploadCredential?.SessionToken) {
+    throw new Error("preUploadStatic \u8FD4\u56DE\u7684\u51ED\u8BC1\u5B57\u6BB5\u4E0D\u5B8C\u6574");
+  }
+  return response;
+}
+function configureTosutil(tosutilPath, config) {
+  const { endpoint, region, accessKeyID, secretAccessKey, sessionToken } = config;
+  execFileSync(
+    tosutilPath,
+    ["config", "-e", endpoint, "-i", accessKeyID, "-k", secretAccessKey, "-t", sessionToken, "-re", region],
+    { stdio: "pipe" }
+  );
+}
+function uploadToTos(tosutilPath, sourceDir, destUrl) {
+  execFileSync(
+    tosutilPath,
+    ["cp", sourceDir, destUrl, "-r", "-flat", "-j", "5", "-p", "3", "-ps", "10485760", "-f"],
+    { stdio: "inherit" }
+  );
+}
+async function resolveBucketId(appId) {
+  console.error(`${LOG_PREFIX} \u83B7\u53D6\u9ED8\u8BA4\u5B58\u50A8\u6876...`);
+  const bucketId = await getDefaultBucketId(appId);
+  console.error(`${LOG_PREFIX} \u9ED8\u8BA4\u5B58\u50A8\u6876: ${bucketId}`);
+  return bucketId;
+}
+function isDirEmpty(dirPath) {
+  const entries = fs25.readdirSync(dirPath);
+  return entries.length === 0;
+}
+
+// src/commands/build/pre-upload-static.handler.ts
+var LOG_PREFIX2 = "[pre-upload-static]";
+function shellEscape(value) {
+  return value.replace(/["\\`$]/g, "\\$&");
+}
+async function preUploadStatic(options) {
+  try {
+    const { appId } = options;
+    console.error(`${LOG_PREFIX2} \u83B7\u53D6\u9ED8\u8BA4\u5B58\u50A8\u6876...`);
+    const bucketId = await getDefaultBucketId(appId);
+    console.error(`${LOG_PREFIX2} \u9ED8\u8BA4\u5B58\u50A8\u6876: ${bucketId}`);
+    console.error(`${LOG_PREFIX2} \u8C03\u7528 preUploadStatic...`);
+    const response = await preUploadStaticAttachment(appId, bucketId);
+    if (response.status_code !== "0") {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${response.status_code}`);
+      return;
+    }
+    const { downloadURLPrefix, uploadPrefix, uploadID, uploadCredential } = response.data || {};
+    if (!downloadURLPrefix || !uploadPrefix || !uploadID) {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u6570\u636E\u4E0D\u5B8C\u6574`);
+      return;
+    }
+    if (!uploadCredential?.AccessKeyID || !uploadCredential?.SecretAccessKey || !uploadCredential?.SessionToken) {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u7684\u51ED\u8BC1\u5B57\u6BB5\u4E0D\u5B8C\u6574`);
+      return;
+    }
+    console.log(`export STATIC_ASSETS_BASE_URL="${shellEscape(downloadURLPrefix)}"`);
+    console.log(`export STATIC_UPLOAD_PREFIX="${shellEscape(uploadPrefix)}"`);
+    console.log(`export STATIC_UPLOAD_ID="${shellEscape(uploadID)}"`);
+    console.log(`export STATIC_UPLOAD_AK="${shellEscape(uploadCredential.AccessKeyID)}"`);
+    console.log(`export STATIC_UPLOAD_SK="${shellEscape(uploadCredential.SecretAccessKey)}"`);
+    console.log(`export STATIC_UPLOAD_TOKEN="${shellEscape(uploadCredential.SessionToken)}"`);
+    console.log(`export STATIC_UPLOAD_BUCKET_ID="${shellEscape(bucketId)}"`);
+    console.error(`${LOG_PREFIX2} \u73AF\u5883\u53D8\u91CF\u5DF2\u8F93\u51FA`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${LOG_PREFIX2} Warning: ${message}`);
+  }
+}
+
 // src/commands/build/index.ts
 var getTokenCommand = {
   name: "get-token",
@@ -6979,10 +7431,28 @@ var getTokenCommand = {
     });
   }
 };
+var uploadStaticCommand = {
+  name: "upload-static",
+  description: "Upload shared/static files to TOS",
+  register(program) {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").option("--static-dir <dir>", "Static files directory", "shared/static").option("--tosutil-path <path>", "Path to tosutil binary", "/workspace/tosutil").option("--endpoint <endpoint>", "TOS endpoint", "tos-cn-beijing.volces.com").option("--region <region>", "TOS region", "cn-beijing").action(async (options) => {
+      await uploadStatic(options);
+    });
+  }
+};
+var preUploadStaticCommand = {
+  name: "pre-upload-static",
+  description: "Get TOS upload info and output as env vars for build.sh eval",
+  register(program) {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").action(async (options) => {
+      await preUploadStatic(options);
+    });
+  }
+};
 var buildCommandGroup = {
   name: "build",
   description: "Build related commands",
-  commands: [getTokenCommand]
+  commands: [getTokenCommand, uploadStaticCommand, preUploadStaticCommand]
 };
 
 // src/commands/index.ts
@@ -6999,12 +7469,12 @@ var commands = [
 ];
 
 // src/index.ts
-var envPath = path21.join(process.cwd(), ".env");
-if (fs25.existsSync(envPath)) {
+var envPath = path22.join(process.cwd(), ".env");
+if (fs26.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path21.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs25.readFileSync(path21.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path22.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs26.readFileSync(path22.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.16-beta.5",
+  "version": "1.1.16-beta.7",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",

package/templates/.spark_project

@@ -0,0 +1,16 @@
+run = ["npm", "run", "dev"] # 默认 spark-cli dev
+hidden = [".config", ".git", "scripts", "node_modules", "dist", ".spark", ".agent", ".agents", "tmp", ".spark_project", ".playwright-cli"]
+lint = ["npm", "run", "lint"]
+test = ["npm", "run", "test"]
+genDbSchema = ["npm", "run", "gen:db-schema"]
+genOpenApiClient = ["npm", "run", "gen:openapi"]
+
+[deployment]
+build = ["npm", "run", "build"]
+run = ["npm", "run", "start"]
+
+[files]
+[files.restrict]
+pathPatterns = ["client/src/api/gen", "package.json", ".spark_project", ".gitignore"]
+[files.hidden]
+pathPatterns = [".config", ".git", "scripts", "node_modules", "dist", ".spark", ".agent", ".agents", "tmp", ".spark_project", ".playwright-cli"]

package/templates/nest-cli.json

@@ -3,7 +3,7 @@
   "collection": "@nestjs/schematics",
   "sourceRoot": "server",
   "compilerOptions": {
-    "deleteOutDir": true,
+    "deleteOutDir": false,
     "tsConfigPath": "tsconfig.node.json",
     "assets": [
       {

package/templates/scripts/build.sh

@@ -83,12 +83,17 @@ STEP_START=$(node -e "console.log(Date.now())")
 
 mkdir -p "$OUT_DIR/dist/client"
 
-# 拷贝 HTML
-cp "$ROOT_DIR/dist/client/"*.html "$OUT_DIR/dist/client/" || true
+# 移动 HTML（从 dist/client 移走，避免残留）
+mv "$ROOT_DIR/dist/client/"*.html "$OUT_DIR/dist/client/" || true
 
 # 拷贝 run.sh 文件
 cp "$ROOT_DIR/scripts/run.sh" "$OUT_DIR/"
 
+# 拷贝 .env 文件（如果存在）
+if [ -f "$ROOT_DIR/.env" ]; then
+  cp "$ROOT_DIR/.env" "$OUT_DIR/"
+fi
+
 # 清理无用文件
 rm -rf "$ROOT_DIR/dist/scripts"
 rm -rf "$ROOT_DIR/dist/tsconfig.node.tsbuildinfo"

package/templates/scripts/dev.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+const readline = require('readline');
+
+// ── Project root ──────────────────────────────────────────────────────────────
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+process.chdir(PROJECT_ROOT);
+
+// ── Load .env ─────────────────────────────────────────────────────────────────
+function loadEnv() {
+  const envPath = path.join(PROJECT_ROOT, '.env');
+  if (!fs.existsSync(envPath)) return;
+  const lines = fs.readFileSync(envPath, 'utf8').split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+loadEnv();
+
+// ── Configuration ─────────────────────────────────────────────────────────────
+const LOG_DIR = process.env.LOG_DIR || 'logs';
+const MAX_RESTART_COUNT = parseInt(process.env.MAX_RESTART_COUNT, 10) || 10;
+const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
+const MAX_DELAY = 60;
+const SERVER_PORT = process.env.SERVER_PORT || '3000';
+const CLIENT_DEV_PORT = process.env.CLIENT_DEV_PORT || '8080';
+
+fs.mkdirSync(LOG_DIR, { recursive: true });
+
+// ── Logging infrastructure ────────────────────────────────────────────────────
+const devStdLogPath = path.join(LOG_DIR, 'dev.std.log');
+const devLogPath = path.join(LOG_DIR, 'dev.log');
+const devStdLogFd = fs.openSync(devStdLogPath, 'a');
+const devLogFd = fs.openSync(devLogPath, 'a');
+
+function timestamp() {
+  const now = new Date();
+  return (
+    now.getFullYear() + '-' +
+    String(now.getMonth() + 1).padStart(2, '0') + '-' +
+    String(now.getDate()).padStart(2, '0') + ' ' +
+    String(now.getHours()).padStart(2, '0') + ':' +
+    String(now.getMinutes()).padStart(2, '0') + ':' +
+    String(now.getSeconds()).padStart(2, '0')
+  );
+}
+
+/** Write to terminal + dev.std.log */
+function writeOutput(msg) {
+  try { process.stdout.write(msg); } catch {}
+  try { fs.writeSync(devStdLogFd, msg); } catch {}
+}
+
+/** Structured event log → terminal + dev.std.log + dev.log */
+function logEvent(level, name, message) {
+  const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
+  writeOutput(msg);
+  try { fs.writeSync(devLogFd, msg); } catch {}
+}
+
+// ── Process group management ──────────────────────────────────────────────────
+function killProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {}
+}
+
+function killOrphansByPort(port) {
+  try {
+    const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 }).trim();
+    if (pids) {
+      const pidList = pids.split('\n').filter(Boolean);
+      for (const p of pidList) {
+        try { process.kill(parseInt(p, 10), 'SIGKILL'); } catch {}
+      }
+      return pidList;
+    }
+  } catch {}
+  return [];
+}
+
+// ── Process supervision ───────────────────────────────────────────────────────
+let stopping = false;
+const managedProcesses = []; // { name, pid, child }
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Start and supervise a process with auto-restart and log piping.
+ * Returns a promise that resolves when the process loop ends.
+ */
+function startProcess({ name, command, args, cleanupPort }) {
+  const logFilePath = path.join(LOG_DIR, `${name}.std.log`);
+  const logFd = fs.openSync(logFilePath, 'a');
+
+  const entry = { name, pid: null, child: null };
+  managedProcesses.push(entry);
+
+  const run = async () => {
+    let restartCount = 0;
+
+    while (!stopping) {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+        cwd: PROJECT_ROOT,
+        env: { ...process.env },
+      });
+
+      entry.pid = child.pid;
+      entry.child = child;
+
+      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
+
+      // Pipe stdout and stderr through readline for timestamped logging
+      const pipeLines = (stream) => {
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        rl.on('line', (line) => {
+          const msg = `[${timestamp()}] [${name}] ${line}\n`;
+          try { fs.writeSync(logFd, msg); } catch {}
+          writeOutput(msg);
+        });
+      };
+      if (child.stdout) pipeLines(child.stdout);
+      if (child.stderr) pipeLines(child.stderr);
+
+      // Wait for the direct child to exit.
+      // NOTE: must use 'exit', not 'close'. With shell:true, grandchild processes
+      // (e.g. nest's server) inherit stdout pipes. 'close' won't fire until ALL
+      // pipe holders exit, causing dev.js to hang when npm/nest dies but server survives.
+      const exitCode = await new Promise((resolve) => {
+        child.on('exit', (code) => resolve(code ?? 1));
+        child.on('error', () => resolve(1));
+      });
+
+      // Kill the entire process group
+      if (entry.pid) {
+        killProcessGroup(entry.pid, 'SIGTERM');
+        await sleep(2000);
+        killProcessGroup(entry.pid, 'SIGKILL');
+      }
+      entry.pid = null;
+      entry.child = null;
+
+      // Port cleanup fallback
+      if (cleanupPort) {
+        const orphans = killOrphansByPort(cleanupPort);
+        if (orphans.length > 0) {
+          logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
+          await sleep(500);
+        }
+      }
+
+      if (stopping) break;
+
+      restartCount++;
+      if (restartCount >= MAX_RESTART_COUNT) {
+        logEvent('ERROR', name, `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`);
+        break;
+      }
+
+      const delay = Math.min(RESTART_DELAY * (1 << (restartCount - 1)), MAX_DELAY);
+      logEvent('WARN', name, `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`);
+      await sleep(delay * 1000);
+    }
+
+    try { fs.closeSync(logFd); } catch {}
+  };
+
+  return run();
+}
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+let cleanupDone = false;
+
+async function cleanup() {
+  if (cleanupDone) return;
+  cleanupDone = true;
+  stopping = true;
+
+  logEvent('INFO', 'main', 'Shutting down all processes...');
+
+  // Kill all managed process groups
+  for (const entry of managedProcesses) {
+    if (entry.pid) {
+      logEvent('INFO', 'main', `Stopping process group (PGID: ${entry.pid})`);
+      killProcessGroup(entry.pid, 'SIGTERM');
+    }
+  }
+
+  // Wait for graceful shutdown
+  await sleep(2000);
+
+  // Force kill any remaining
+  for (const entry of managedProcesses) {
+    if (entry.pid) {
+      logEvent('WARN', 'main', `Force killing process group (PGID: ${entry.pid})`);
+      killProcessGroup(entry.pid, 'SIGKILL');
+    }
+  }
+
+  // Port cleanup fallback
+  killOrphansByPort(SERVER_PORT);
+  killOrphansByPort(CLIENT_DEV_PORT);
+
+  logEvent('INFO', 'main', 'All processes stopped');
+
+  try { fs.closeSync(devStdLogFd); } catch {}
+  try { fs.closeSync(devLogFd); } catch {}
+
+  process.exit(0);
+}
+
+process.on('SIGTERM', cleanup);
+process.on('SIGINT', cleanup);
+process.on('SIGHUP', cleanup);
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+async function main() {
+  logEvent('INFO', 'main', '========== Dev session started ==========');
+
+  // Initialize action plugins
+  writeOutput('\n🔌 Initializing action plugins...\n');
+  try {
+    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
+    writeOutput('✅ Action plugins initialized\n\n');
+  } catch {
+    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
+  }
+
+  // Start server and client
+  const serverPromise = startProcess({
+    name: 'server',
+    command: 'npm',
+    args: ['run', 'dev:server'],
+    cleanupPort: SERVER_PORT,
+  });
+
+  const clientPromise = startProcess({
+    name: 'client',
+    command: 'npm',
+    args: ['run', 'dev:client'],
+    cleanupPort: CLIENT_DEV_PORT,
+  });
+
+  writeOutput(`📋 Dev processes running. Press Ctrl+C to stop.\n`);
+  writeOutput(`📄 Logs: ${devStdLogPath}\n\n`);
+
+  // Wait for both (they loop until stopping or max restarts)
+  await Promise.all([serverPromise, clientPromise]);
+
+  if (!cleanupDone) {
+    await cleanup();
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/templates/scripts/dev.sh

@@ -1,245 +1,2 @@
 #!/usr/bin/env bash
-# This file is auto-generated by @lark-apaas/fullstack-cli
-
-set -uo pipefail
-
-# Ensure the script always runs from the project root
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-
-# Configuration
-LOG_DIR=${LOG_DIR:-logs}
-DEV_LOG="${LOG_DIR}/dev.log"
-MAX_RESTART_COUNT=${MAX_RESTART_COUNT:-10}
-RESTART_DELAY=${RESTART_DELAY:-2}
-
-# Process tracking
-SERVER_PID=""
-CLIENT_PID=""
-PARENT_PID=$$
-STOP_FLAG_FILE="/tmp/dev_sh_stop_$$"
-CLEANUP_DONE=false
-
-mkdir -p "${LOG_DIR}"
-
-# Redirect all stdout/stderr to both terminal and log file
-DEV_STD_LOG="${LOG_DIR}/dev.std.log"
-exec > >(tee -a "$DEV_STD_LOG") 2>&1
-
-# Log event to dev.log with timestamp
-log_event() {
-  local level=$1
-  local process_name=$2
-  local message=$3
-  local msg="[$(date '+%Y-%m-%d %H:%M:%S')] [${level}] [${process_name}] ${message}"
-  echo "$msg"
-  echo "$msg" >> "${DEV_LOG}"
-}
-
-# Check if PID is valid (positive integer and process exists)
-is_valid_pid() {
-  local pid=$1
-  [[ -n "$pid" ]] && [[ "$pid" =~ ^[0-9]+$ ]] && [[ "$pid" -gt 0 ]] && kill -0 "$pid" 2>/dev/null
-}
-
-# Check if parent process is still alive
-is_parent_alive() {
-  kill -0 "$PARENT_PID" 2>/dev/null
-}
-
-# Check if should stop (parent exited or stop flag exists)
-should_stop() {
-  [[ -f "$STOP_FLAG_FILE" ]] || ! is_parent_alive
-}
-
-# Kill entire process tree (process and all descendants)
-kill_tree() {
-  local pid=$1
-  local signal=${2:-TERM}
-
-  # Get all descendant PIDs
-  local children
-  children=$(pgrep -P "$pid" 2>/dev/null) || true
-
-  # Recursively kill children first
-  for child in $children; do
-    kill_tree "$child" "$signal"
-  done
-
-  # Kill the process itself
-  if kill -0 "$pid" 2>/dev/null; then
-    kill -"$signal" "$pid" 2>/dev/null || true
-  fi
-}
-
-# Start a process with supervision
-# $1: name
-# $2: command
-# $3: cleanup port for orphan processes (optional)
-start_supervised_process() {
-  local name=$1
-  local cmd=$2
-  local cleanup_port=${3:-""}
-  local log_file="${LOG_DIR}/${name}.std.log"
-
-  (
-    local restart_count=0
-    local child_pid=""
-    local max_delay=60  # Maximum delay in seconds
-
-    # Handle signals to kill child process tree
-    trap 'if [[ -n "$child_pid" ]]; then kill_tree "$child_pid" TERM; fi' TERM INT
-
-    while true; do
-      # Check if we should stop (parent exited or stop flag)
-      if should_stop; then
-        log_event "INFO" "$name" "Process stopped (parent exited or user requested)"
-        break
-      fi
-
-      # Start command in background and capture output with timestamps
-      eval "$cmd" > >(
-        while IFS= read -r line; do
-          local msg="[$(date '+%Y-%m-%d %H:%M:%S')] [${name}] ${line}"
-          echo "$msg"
-          echo "$msg" >> "$log_file"
-        done
-      ) 2>&1 &
-      child_pid=$!
-
-      log_event "INFO" "$name" "Process started (PID: ${child_pid}): ${cmd}"
-
-      # Wait for child to exit
-      set +e
-      wait "$child_pid"
-      exit_code=$?
-      set -e
-
-      # Kill entire process tree to avoid orphans
-      if [[ -n "$child_pid" ]]; then
-        kill_tree "$child_pid" TERM
-        sleep 0.5
-        kill_tree "$child_pid" KILL
-      fi
-      child_pid=""
-
-      # Cleanup orphan processes by port (for processes that escaped kill_tree)
-      if [[ -n "$cleanup_port" ]]; then
-        local orphan_pids
-        orphan_pids=$(lsof -ti ":${cleanup_port}" 2>/dev/null) || true
-        if [[ -n "$orphan_pids" ]]; then
-          log_event "WARN" "$name" "Killing orphan processes on port ${cleanup_port}: $(echo $orphan_pids | tr '\n' ' ')"
-          echo "$orphan_pids" | xargs kill -9 2>/dev/null || true
-          sleep 0.5
-        fi
-      fi
-
-      # Check if we should stop (parent exited or stop flag)
-      if should_stop; then
-        log_event "INFO" "$name" "Process stopped (parent exited or user requested)"
-        break
-      fi
-
-      # Process exited unexpectedly, restart
-      restart_count=$((restart_count + 1))
-
-      if [[ $restart_count -ge $MAX_RESTART_COUNT ]]; then
-        log_event "ERROR" "$name" "Max restart count (${MAX_RESTART_COUNT}) reached, giving up"
-        break
-      fi
-
-      # Exponential backoff: delay = RESTART_DELAY * 2^(restart_count-1), capped at max_delay
-      local delay=$((RESTART_DELAY * (1 << (restart_count - 1))))
-      if [[ $delay -gt $max_delay ]]; then
-        delay=$max_delay
-      fi
-
-      log_event "WARN" "$name" "Process exited with code ${exit_code}, restarting (${restart_count}/${MAX_RESTART_COUNT}) in ${delay}s..."
-      sleep "$delay"
-    done
-  ) &
-}
-
-# Cleanup function
-cleanup() {
-  # Prevent multiple cleanup calls
-  if [[ "$CLEANUP_DONE" == "true" ]]; then
-    return
-  fi
-  CLEANUP_DONE=true
-
-  log_event "INFO" "main" "Shutting down all processes..."
-
-  # Create stop flag to signal child processes
-  touch "$STOP_FLAG_FILE"
-
-  # Kill entire process trees (TERM first)
-  for pid in $SERVER_PID $CLIENT_PID; do
-    if is_valid_pid "$pid"; then
-      log_event "INFO" "main" "Stopping process tree (PID: ${pid})"
-      kill_tree "$pid" TERM
-    fi
-  done
-
-  # Kill any remaining background jobs
-  local bg_pids
-  bg_pids=$(jobs -p 2>/dev/null) || true
-  if [[ -n "$bg_pids" ]]; then
-    for pid in $bg_pids; do
-      kill_tree "$pid" TERM
-    done
-  fi
-
-  # Wait for processes to terminate
-  sleep 1
-
-  # Force kill if still running
-  for pid in $SERVER_PID $CLIENT_PID; do
-    if is_valid_pid "$pid"; then
-      log_event "WARN" "main" "Force killing process tree (PID: ${pid})"
-      kill_tree "$pid" KILL
-    fi
-  done
-
-  # Cleanup stop flag
-  rm -f "$STOP_FLAG_FILE"
-
-  log_event "INFO" "main" "All processes stopped"
-}
-
-# Set up signal handlers
-trap cleanup EXIT INT TERM HUP
-
-# Remove any stale stop flag
-rm -f "$STOP_FLAG_FILE"
-
-# Initialize dev.log
-echo "" >> "${DEV_LOG}"
-log_event "INFO" "main" "========== Dev session started =========="
-
-# Initialize action plugins before starting dev servers
-echo "🔌 Initializing action plugins..."
-if fullstack-cli action-plugin init; then
-  echo "✅ Action plugins initialized"
-else
-  echo "⚠️  Action plugin initialization failed, continuing anyway..."
-fi
-echo ""
-
-# Start server (cleanup orphan processes on SERVER_PORT)
-start_supervised_process "server" "npm run dev:server" "${SERVER_PORT:-3000}"
-SERVER_PID=$!
-log_event "INFO" "server" "Supervisor started with PID ${SERVER_PID}"
-
-# Start client (cleanup orphan processes on CLIENT_DEV_PORT)
-start_supervised_process "client" "npm run dev:client" "${CLIENT_DEV_PORT:-8080}"
-CLIENT_PID=$!
-log_event "INFO" "client" "Supervisor started with PID ${CLIENT_PID}"
-
-log_event "INFO" "main" "All processes started, monitoring..."
-echo ""
-echo "📋 Dev processes running. Press Ctrl+C to stop."
-echo "📄 Logs: ${DEV_STD_LOG}"
-echo ""
-
-# Wait for all background processes
-wait
+exec node "$(dirname "$0")/dev.js" "$@"