create-caspian-app 0.0.1

package/dist/settings/python-server.ts

@@ -0,0 +1,173 @@
+import { spawn, ChildProcess } from "child_process";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { join } from "path";
+import { Socket } from "net";
+
+let pythonProcess: ChildProcess | null = null;
+let isRestarting = false;
+
+function isWindows(): boolean {
+  return platform() === "win32";
+}
+
+function getVenvPythonPath(): string {
+  const venvPython = isWindows()
+    ? join(".venv", "Scripts", "python.exe")
+    : join(".venv", "bin", "python");
+
+  if (!existsSync(venvPython)) {
+    console.warn(`⚠ Virtual environment not found, using system python`);
+    return isWindows() ? "python" : "python3";
+  }
+  return venvPython;
+}
+
+export function waitForPort(port: number, timeout = 10000): Promise<boolean> {
+  const start = Date.now();
+  return new Promise((resolve) => {
+    const check = () => {
+      if (Date.now() - start > timeout) {
+        resolve(false);
+        return;
+      }
+      const socket = new Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        setTimeout(check, 100);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        setTimeout(check, 100);
+      });
+      socket.connect(port, "127.0.0.1");
+    };
+    check();
+  });
+}
+
+export function waitForPortRelease(
+  port: number,
+  timeout = 5000
+): Promise<boolean> {
+  const start = Date.now();
+  return new Promise((resolve) => {
+    const check = () => {
+      if (Date.now() - start > timeout) {
+        resolve(false);
+        return;
+      }
+      const socket = new Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        setTimeout(check, 100);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", (err: any) => {
+        socket.destroy();
+        if (err.code === "ECONNREFUSED") {
+          resolve(true);
+        } else {
+          setTimeout(check, 100);
+        }
+      });
+      socket.connect(port, "127.0.0.1");
+    };
+    check();
+  });
+}
+
+async function killProcessTree(child: ChildProcess): Promise<void> {
+  if (!child || child.exitCode !== null) return;
+  const pid = child.pid;
+  if (!pid) return;
+
+  if (isWindows()) {
+    try {
+      await new Promise<void>((resolve) => {
+        const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+          stdio: "ignore",
+          shell: true,
+          windowsHide: true,
+        });
+        killer.on("exit", () => resolve());
+        killer.on("error", () => resolve());
+      });
+    } catch (e) {}
+  } else {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+    }
+  }
+}
+
+function spawnPython(port: number): ChildProcess {
+  const pythonPath = getVenvPythonPath();
+  const args = ["-u", "main.py"];
+
+  console.log(`→ Starting Python server on port ${port}...`);
+
+  const child = spawn(pythonPath, args, {
+    stdio: "inherit",
+    shell: false,
+    detached: !isWindows(),
+    env: { ...process.env, PYTHONUNBUFFERED: "1", PORT: String(port) },
+  });
+
+  child.on("error", (err) => console.error("Failed to start Python:", err));
+  return child;
+}
+
+export function startPythonServer(port: number): void {
+  if (pythonProcess && pythonProcess.exitCode === null) return;
+  pythonProcess = spawnPython(port);
+}
+
+export async function restartPythonServer(port: number): Promise<void> {
+  if (isRestarting) return;
+  isRestarting = true;
+
+  try {
+    console.log("→ Restarting Python server...");
+    const prev = pythonProcess;
+    pythonProcess = null;
+
+    if (prev) {
+      await killProcessTree(prev);
+      await waitForPortRelease(port);
+    }
+
+    pythonProcess = spawnPython(port);
+  } finally {
+    isRestarting = false;
+  }
+}
+
+export function stopPythonServer(): void {
+  const prev = pythonProcess;
+  pythonProcess = null;
+  if (prev) killProcessTree(prev);
+}
+
+process.on("exit", () => stopPythonServer());
+process.on("SIGINT", () => {
+  stopPythonServer();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  stopPythonServer();
+  process.exit(0);
+});

package/dist/settings/utils.ts

@@ -0,0 +1,239 @@
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import chokidar, { FSWatcher } from "chokidar";
+import { spawn, ChildProcess, execFile } from "child_process";
+import { relative } from "path";
+
+export const PUBLIC_DIR = "public";
+export const SRC_DIR = "src";
+export const APP_DIR = "src/app";
+
+export function getFileMeta() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  return { __filename, __dirname };
+}
+
+export type WatchEvent = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+
+export const DEFAULT_IGNORES: (string | RegExp)[] = [
+  /(^|[\/\\])\../,
+  "**/node_modules/**",
+  "**/vendor/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.cache/**",
+  "**/*.log",
+  "**/*.tmp",
+  "**/*.swp",
+];
+
+export const DEFAULT_AWF = { stabilityThreshold: 300, pollInterval: 100 };
+
+export function createSrcWatcher(
+  root: string,
+  opts: {
+    exts?: string[];
+    onEvent: (event: WatchEvent, absPath: string, relPath: string) => void;
+    ignored?: (string | RegExp)[];
+    awaitWriteFinish?: { stabilityThreshold: number; pollInterval: number };
+    logPrefix?: string;
+    usePolling?: boolean;
+    interval?: number;
+  }
+): FSWatcher {
+  const {
+    exts,
+    onEvent,
+    ignored = DEFAULT_IGNORES,
+    awaitWriteFinish = DEFAULT_AWF,
+    logPrefix = "watch",
+    usePolling = true,
+  } = opts;
+
+  const watcher = chokidar.watch(root, {
+    ignoreInitial: true,
+    persistent: true,
+    ignored,
+    awaitWriteFinish,
+    usePolling,
+    interval: opts.interval ?? 1000,
+  });
+
+  watcher
+    .on("ready", () => {
+      console.log(`[${logPrefix}] Watching ${root.replace(/\\/g, "/")}/**/*`);
+    })
+    .on("all", (event: WatchEvent, filePath: string) => {
+      if (exts && exts.length > 0) {
+        const ok = exts.some((ext) => filePath.endsWith(ext));
+        if (!ok) return;
+      }
+      const rel = relative(root, filePath).replace(/\\/g, "/");
+      if (event === "add" || event === "change" || event === "unlink") {
+        onEvent(event, filePath, rel);
+      }
+    })
+    .on("error", (err) => console.error(`[${logPrefix}] Error:`, err));
+
+  return watcher;
+}
+
+export class DebouncedWorker {
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+  private queued = false;
+
+  constructor(
+    private work: () => Promise<void> | void,
+    private debounceMs = 350,
+    private name = "worker"
+  ) {}
+
+  schedule(reason?: string) {
+    if (reason) console.log(`[${this.name}] ${reason} → scheduled`);
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.runNow().catch(() => {});
+    }, this.debounceMs);
+  }
+
+  private async runNow() {
+    if (this.running) {
+      this.queued = true;
+      return;
+    }
+    this.running = true;
+    try {
+      await this.work();
+    } catch (err) {
+      console.error(`[${this.name}] error:`, err);
+    } finally {
+      this.running = false;
+      if (this.queued) {
+        this.queued = false;
+        this.runNow().catch(() => {});
+      }
+    }
+  }
+}
+
+export function createRestartableProcess(spec: {
+  name: string;
+  cmd: string;
+  args?: string[];
+  stdio?: "inherit" | [any, any, any];
+  gracefulSignal?: NodeJS.Signals;
+  forceKillAfterMs?: number;
+  windowsKillTree?: boolean;
+  onStdout?: (buf: Buffer) => void;
+  onStderr?: (buf: Buffer) => void;
+}) {
+  const {
+    name,
+    cmd,
+    args = [],
+    stdio = ["ignore", "pipe", "pipe"],
+    gracefulSignal = "SIGINT",
+    forceKillAfterMs = 2000,
+    windowsKillTree = true,
+    onStdout,
+    onStderr,
+  } = spec;
+
+  let child: ChildProcess | null = null;
+
+  function start() {
+    console.log(`[${name}] Starting: ${cmd} ${args.join(" ")}`.trim());
+    child = spawn(cmd, args, { stdio, windowsHide: true });
+
+    child.stdout?.on("data", (buf: Buffer) => {
+      if (onStdout) onStdout(buf);
+      else process.stdout.write(`[${name}] ${buf.toString()}`);
+    });
+
+    child.stderr?.on("data", (buf: Buffer) => {
+      if (onStderr) onStderr(buf);
+      else process.stderr.write(`[${name}:err] ${buf.toString()}`);
+    });
+
+    child.on("close", (code) => {
+      console.log(`[${name}] Exited with code ${code}`);
+    });
+
+    child.on("error", (err) => {
+      console.error(`[${name}] Failed to start:`, err);
+    });
+
+    return child;
+  }
+
+  function killOnWindows(pid: number): Promise<void> {
+    return new Promise((resolve) => {
+      const cp = execFile("taskkill", ["/F", "/T", "/PID", String(pid)], () =>
+        resolve()
+      );
+      cp.on("error", () => resolve());
+    });
+  }
+
+  async function stop(): Promise<void> {
+    if (!child || child.killed) return;
+    const pid = child.pid!;
+    console.log(`[${name}] Stopping…`);
+
+    if (process.platform === "win32" && windowsKillTree) {
+      await killOnWindows(pid);
+      child = null;
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const done = () => resolve();
+      child!.once("close", done).once("exit", done).once("disconnect", done);
+      try {
+        child!.kill(gracefulSignal);
+      } catch {
+        resolve();
+      }
+      setTimeout(() => {
+        if (child && !child.killed) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {}
+        }
+      }, forceKillAfterMs);
+    });
+    child = null;
+  }
+
+  async function restart(reason?: string) {
+    if (reason) console.log(`[${name}] Restart requested: ${reason}`);
+    await stop();
+    return start();
+  }
+
+  function getChild() {
+    return child;
+  }
+
+  return { start, stop, restart, getChild };
+}
+
+export function onExit(fn: () => Promise<void> | void) {
+  const wrap = (sig: string) => async () => {
+    console.log(`[proc] Received ${sig}, shutting down…`);
+    try {
+      await fn();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", wrap("SIGINT"));
+  process.on("SIGTERM", wrap("SIGTERM"));
+  process.on("uncaughtException", async (err) => {
+    console.error("[proc] Uncaught exception:", err);
+    await wrap("uncaughtException")();
+  });
+}

package/dist/settings/vite-plugins/generate-global-types.ts

@@ -0,0 +1,246 @@
+import { Plugin } from "vite";
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import ts from "typescript";
+
+export function generateGlobalTypes(): Plugin {
+  const dtsPath = path.resolve(process.cwd(), ".pp", "global-functions.d.ts");
+
+  return {
+    name: "generate-global-types",
+
+    buildStart() {
+      const mainPath = path.resolve(process.cwd(), "ts", "main.ts");
+
+      if (!existsSync(mainPath)) {
+        console.warn("⚠️  ts/main.ts not found, skipping type generation");
+        return;
+      }
+
+      const content = readFileSync(mainPath, "utf-8");
+      const globals = parseGlobalSingletons(content, mainPath);
+
+      if (globals.length === 0) {
+        console.warn("⚠️  No createGlobalSingleton calls found");
+        return;
+      }
+
+      generateDtsWithTypeChecker(globals, dtsPath, mainPath);
+    },
+  };
+}
+interface GlobalDeclaration {
+  name: string;
+  importPath: string;
+  exportName: string;
+}
+
+function parseGlobalSingletons(
+  content: string,
+  filePath: string
+): GlobalDeclaration[] {
+  const sf = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+
+  const globals: GlobalDeclaration[] = [];
+  const importMap = new Map<string, { path: string; originalName: string }>();
+
+  sf.statements.forEach((stmt) => {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+      const moduleSpecifier = (stmt.moduleSpecifier as ts.StringLiteral).text;
+
+      if (stmt.importClause.namedBindings) {
+        if (ts.isNamedImports(stmt.importClause.namedBindings)) {
+          stmt.importClause.namedBindings.elements.forEach((element) => {
+            const localName = element.name.text;
+            const importedName = element.propertyName
+              ? element.propertyName.text
+              : localName;
+
+            importMap.set(localName, {
+              path: moduleSpecifier,
+              originalName: importedName,
+            });
+          });
+        }
+      }
+    }
+  });
+
+  function visit(node: ts.Node) {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "createGlobalSingleton"
+    ) {
+      if (node.arguments.length >= 2) {
+        const nameArg = node.arguments[0];
+        const valueArg = node.arguments[1];
+
+        if (ts.isStringLiteral(nameArg) && ts.isIdentifier(valueArg)) {
+          const name = nameArg.text;
+          const variable = valueArg.text;
+          const importInfo = importMap.get(variable);
+
+          if (importInfo) {
+            globals.push({
+              name,
+              importPath: importInfo.path,
+              exportName: importInfo.originalName,
+            });
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sf);
+  return globals;
+}
+
+function generateDtsWithTypeChecker(
+  globals: GlobalDeclaration[],
+  dtsPath: string,
+  mainPath: string
+) {
+  const configPath = ts.findConfigFile(
+    process.cwd(),
+    ts.sys.fileExists,
+    "tsconfig.json"
+  );
+
+  const { config } = configPath
+    ? ts.readConfigFile(configPath, ts.sys.readFile)
+    : { config: {} };
+
+  const { options } = ts.parseJsonConfigFileContent(
+    config,
+    ts.sys,
+    process.cwd()
+  );
+
+  const program = ts.createProgram([mainPath], options);
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(mainPath);
+
+  if (!sourceFile) {
+    console.warn("⚠️  Could not load main.ts for type checking");
+    generateFallbackDts(globals, dtsPath);
+    return;
+  }
+
+  const signatures = new Map<string, string>();
+
+  const importMap = new Map<string, ts.ImportDeclaration>();
+  sourceFile.statements.forEach((stmt) => {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause?.namedBindings) {
+      if (ts.isNamedImports(stmt.importClause.namedBindings)) {
+        stmt.importClause.namedBindings.elements.forEach((element) => {
+          importMap.set(element.name.text, stmt);
+        });
+      }
+    }
+  });
+
+  globals.forEach(({ name, exportName }) => {
+    try {
+      const importDecl = importMap.get(exportName);
+      if (!importDecl || !importDecl.importClause?.namedBindings) {
+        signatures.set(name, "(...args: any[]) => any");
+        return;
+      }
+
+      if (ts.isNamedImports(importDecl.importClause.namedBindings)) {
+        const importSpec = importDecl.importClause.namedBindings.elements.find(
+          (el) => el.name.text === exportName
+        );
+
+        if (importSpec) {
+          const symbol = checker.getSymbolAtLocation(importSpec.name);
+          if (symbol) {
+            const type = checker.getTypeOfSymbolAtLocation(
+              symbol,
+              importSpec.name
+            );
+            const signature = checker.typeToString(
+              type,
+              undefined,
+              ts.TypeFormatFlags.NoTruncation
+            );
+            signatures.set(name, signature);
+            return;
+          }
+        }
+      }
+
+      signatures.set(name, "(...args: any[]) => any");
+    } catch (error) {
+      console.warn(`⚠️  Failed to extract type for ${name}:`, error);
+      signatures.set(name, "(...args: any[]) => any");
+    }
+  });
+
+  const declarations = globals
+    .map(({ name }) => {
+      const sig = signatures.get(name) || "(...args: any[]) => any";
+      return `  const ${name}: ${sig};`;
+    })
+    .join("\n");
+
+  const windowDeclarations = globals
+    .map(({ name }) => `    ${name}: typeof globalThis.${name};`)
+    .join("\n");
+
+  const content = `// Auto-generated by Vite plugin
+// Do not edit manually - regenerate with: npm run dev or npm run build
+// Source: ts/main.ts
+
+declare global {
+${declarations}
+
+  interface Window {
+${windowDeclarations}
+  }
+}
+
+export {};
+`;
+
+  const dir = path.dirname(dtsPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(dtsPath, content, "utf-8");
+  console.log(`✅ Generated ${path.relative(process.cwd(), dtsPath)}`);
+}
+
+function generateFallbackDts(globals: GlobalDeclaration[], dtsPath: string) {
+  const declarations = globals
+    .map(({ name }) => `  const ${name}: (...args: any[]) => any;`)
+    .join("\n");
+
+  const windowDeclarations = globals
+    .map(({ name }) => `    ${name}: typeof globalThis.${name};`)
+    .join("\n");
+
+  const content = `// Auto-generated by Vite plugin
+declare global {
+${declarations}
+
+  interface Window {
+${windowDeclarations}
+  }
+}
+
+export {};
+`;
+
+  writeFileSync(dtsPath, content, "utf-8");
+}