gencow 0.1.165 → 0.1.166

package/lib/dev-local-command.mjs

@@ -7,13 +7,33 @@ import {
   formatAuthSchemaConflictMessage,
   isServerCodegenWatchPath,
 } from "./codegen-command.mjs";
+import { runDrizzleGenerateWithFallback } from "./drizzle-generate.mjs";
 
 export function shouldUseLocalDev({ devArgs, processEnv = process.env }) {
   return processEnv.GENCOW_LOCAL === "1" || devArgs.includes("--local");
 }
 
-export function buildKillPortsCommand(ports) {
-  const flags = ports.map((port) => `-ti:${port}`).join(" ");
+function normalizePortList(ports) {
+  const seen = new Set();
+  const normalized = [];
+  for (const port of ports) {
+    const value = String(port).trim();
+    if (!/^\d+$/.test(value)) continue;
+    if (seen.has(value)) continue;
+    seen.add(value);
+    normalized.push(value);
+  }
+  return normalized;
+}
+
+export function buildKillPortsCommand(ports, platform = process.platform) {
+  const normalized = normalizePortList(ports);
+  if (normalized.length === 0) return "";
+  if (platform === "win32") {
+    const list = normalized.join(",");
+    return `powershell -NoProfile -ExecutionPolicy Bypass -Command "$ports=@(${list}); Get-NetTCPConnection -LocalPort $ports -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess -Unique | ForEach-Object { Stop-Process -Id $_ -Force -ErrorAction SilentlyContinue }"`;
+  }
+  const flags = normalized.map((port) => `-ti:${port}`).join(" ");
   return `lsof ${flags} 2>/dev/null | xargs kill -9 2>/dev/null || true`;
 }
 
@@ -121,7 +141,8 @@ export function createDevLocalCommands({
     const dashPort = config.dashboardPort || 5100;
     const samplePort = config.samplePort || 5001;
     try {
-      execSyncImpl(buildKillPortsCommand([apiPort, dashPort, samplePort]), { stdio: "ignore" });
+      const killCommand = buildKillPortsCommand([apiPort, dashPort, samplePort]);
+      if (killCommand) execSyncImpl(killCommand, { stdio: "ignore" });
     } catch {
       /* ignore */
     }
@@ -147,11 +168,13 @@ export function createDevLocalCommands({
           stdio: "inherit",
         });
       } else {
-        const dk = drizzleKitCmdImpl("generate");
-        execSyncImpl(dk.cmd, {
+        runDrizzleGenerateWithFallback({
           cwd,
-          env: { ...genEnv, ...dk.env },
+          drizzleKitCmdImpl,
+          env: genEnv,
+          execSyncImpl,
           stdio: "inherit",
+          warnImpl,
         });
       }
       successImpl("Schema -> migrations synced");
@@ -237,7 +260,8 @@ export function createDevLocalCommands({
 
     const killAll = () => {
       try {
-        execSyncImpl(buildKillPortsCommand([dashPort, samplePort]), { stdio: "ignore" });
+        const killCommand = buildKillPortsCommand([dashPort, samplePort]);
+        if (killCommand) execSyncImpl(killCommand, { stdio: "ignore" });
       } catch {
         /* ignore */
       }

package/lib/drizzle-generate.mjs

@@ -0,0 +1,34 @@
+export function getCommandErrorMessage(error) {
+  return (error?.stderr?.toString() || error?.message || "").trim();
+}
+
+export function shouldRetryLegacyGenerate(error) {
+  const message = getCommandErrorMessage(error);
+  return message.includes("unknown command 'generate'") && message.includes("generate:pg");
+}
+
+export function runDrizzleGenerateWithFallback({
+  cwd,
+  drizzleKitCmdImpl,
+  env = {},
+  execSyncImpl,
+  stdio = "inherit",
+  warnImpl,
+}) {
+  const run = (subcmd) => {
+    const dk = drizzleKitCmdImpl(subcmd);
+    execSyncImpl(dk.cmd, {
+      cwd,
+      env: { ...env, ...dk.env },
+      stdio,
+    });
+  };
+
+  try {
+    run("generate");
+  } catch (error) {
+    if (!shouldRetryLegacyGenerate(error)) throw error;
+    warnImpl?.("drizzle-kit uses legacy generate:pg; retrying migration generation...");
+    run("generate:pg");
+  }
+}

package/lib/static-deploy-command.mjs

@@ -1,8 +1,8 @@
-import { execSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import { resolve } from "path";
+import { relative, resolve } from "path";
 import { BOLD, CYAN, DIM, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
 import { platformFetch, rpcMutation } from "./platform-client.mjs";
+import { createTarGzipArchive } from "./tar-archive.mjs";
 
 export function resolveStaticDeployDir({
   staticDirArg,
@@ -94,7 +94,7 @@ export function findBuiltApiReferenceFiles({
       const content = readFileSyncImpl(file, "utf8");
       return content.includes("/api/query") || content.includes("/api/mutation");
     })
-    .map((file) => file.replace(`${targetDir}/`, ""))
+    .map((file) => relative(targetDir, file).replace(/\\/g, "/"))
     .sort();
 }
 
@@ -134,7 +134,6 @@ export function createStaticDeployRuntime({
   createInterfaceImpl,
   cwdImpl = () => process.cwd(),
   errorImpl = error,
-  execSyncImpl = execSync,
   existsSyncImpl = existsSync,
   exitImpl = (code) => process.exit(code),
   infoImpl = info,
@@ -147,6 +146,7 @@ export function createStaticDeployRuntime({
   setTimeoutImpl = setTimeout,
   statSyncImpl = statSync,
   successImpl = success,
+  tarCreateImpl,
   unlinkSyncImpl = unlinkSync,
   warnImpl = warn,
   writeFileSyncImpl = writeFileSync,
@@ -223,8 +223,11 @@ export function createStaticDeployRuntime({
     mkdirSyncImpl(resolvePathImpl(tmpBundle, ".."), { recursive: true });
 
     try {
-      execSyncImpl(`COPYFILE_DISABLE=1 tar -czf "${tmpBundle}" -C "${resolvePathImpl(cwd, targetDir)}" .`, {
-        cwd,
+      await createTarGzipArchive({
+        cwd: resolvePathImpl(cwd, targetDir),
+        file: tmpBundle,
+        entries: ["."],
+        tarCreateImpl,
       });
     } catch (error) {
       errorImpl(`Packaging failed: ${error.message}`);

package/lib/tar-archive.mjs

@@ -0,0 +1,61 @@
+function normalizeTarPath(value) {
+  return String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/\/+$/, "");
+}
+
+function splitTarPath(value) {
+  return normalizeTarPath(value).split("/").filter(Boolean);
+}
+
+function segmentMatchesPattern(segment, pattern) {
+  if (pattern.endsWith(".*")) {
+    return segment.startsWith(pattern.slice(0, -1));
+  }
+  return segment === pattern;
+}
+
+function matchesTarExclude(entryPath, pattern) {
+  const normalizedPattern = normalizeTarPath(pattern);
+  if (!normalizedPattern) return false;
+  const entrySegments = splitTarPath(entryPath);
+  const patternSegments = splitTarPath(normalizedPattern);
+  if (entrySegments.length === 0 || patternSegments.length === 0) return false;
+
+  if (patternSegments.length === 1) {
+    return entrySegments.some((segment) => segmentMatchesPattern(segment, patternSegments[0]));
+  }
+
+  for (let index = 0; index <= entrySegments.length - patternSegments.length; index += 1) {
+    const matches = patternSegments.every((segment, offset) =>
+      segmentMatchesPattern(entrySegments[index + offset], segment),
+    );
+    if (matches) return true;
+  }
+  return false;
+}
+
+export function shouldIncludeTarEntry(entryPath, excludes = []) {
+  return !excludes.some((pattern) => matchesTarExclude(entryPath, pattern));
+}
+
+export async function createTarGzipArchive({
+  cwd,
+  file,
+  entries = ["."],
+  excludes = [],
+  tarCreateImpl,
+}) {
+  const createImpl = tarCreateImpl ?? (await import("tar")).create;
+  const options = {
+    cwd,
+    file,
+    gzip: true,
+    portable: true,
+  };
+  if (excludes.length > 0) {
+    options.filter = (entryPath) => shouldIncludeTarEntry(entryPath, excludes);
+  }
+  await createImpl(options, entries);
+}

package/lib/template-marketplace-command.mjs

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { basename, resolve } from "path";
 import { BOLD, CYAN, DIM, GREEN, RESET, error, info, log, success } from "./output.mjs";
 import { platformFetch, requireCreds } from "./platform-client.mjs";
+import { createTarGzipArchive } from "./tar-archive.mjs";
 import {
   buildTemplateTarExcludes,
   detectStaticTemplateProject,
@@ -39,29 +40,42 @@ function centsFromPrice(value) {
   return Math.round(numeric * 100);
 }
 
-function shellQuote(value) {
-  return `'${String(value).replace(/'/g, "'\\''")}'`;
-}
-
-function createSourceBundle({ cwd, staticOutputDir, execSyncImpl = execSync, mkdirSyncImpl = mkdirSync }) {
+async function createSourceBundle({ cwd, staticOutputDir, mkdirSyncImpl = mkdirSync, tarCreateImpl }) {
   const out = resolve(cwd, ".gencow", "template-source.tar.gz");
   mkdirSyncImpl(resolve(cwd, ".gencow"), { recursive: true });
-  const excludes = buildTemplateTarExcludes(staticOutputDir)
-    .map((item) => `--exclude=${shellQuote(item)}`)
-    .join(" ");
-  execSyncImpl(`COPYFILE_DISABLE=1 tar ${excludes} -czf ${shellQuote(out)} .`, { cwd });
+  await createTarGzipArchive({
+    cwd,
+    file: out,
+    entries: ["."],
+    excludes: buildTemplateTarExcludes(staticOutputDir),
+    tarCreateImpl,
+  });
   return out;
 }
 
-function createStaticBundle({ cwd, outputDir, execSyncImpl = execSync, mkdirSyncImpl = mkdirSync }) {
+async function createStaticBundle({ cwd, outputDir, mkdirSyncImpl = mkdirSync, resolvePathImpl = resolve, tarCreateImpl }) {
   const out = resolve(cwd, ".gencow", "template-static.tar.gz");
   mkdirSyncImpl(resolve(cwd, ".gencow"), { recursive: true });
-  execSyncImpl(`COPYFILE_DISABLE=1 tar -czf ${shellQuote(out)} -C ${shellQuote(resolve(cwd, outputDir))} .`, {
-    cwd,
+  await createTarGzipArchive({
+    cwd: resolvePathImpl(cwd, outputDir),
+    file: out,
+    entries: ["."],
+    tarCreateImpl,
   });
   return out;
 }
 
+async function extractTemplateArchive({
+  archive,
+  targetDir,
+  mkdirSyncImpl = mkdirSync,
+  tarExtractImpl,
+}) {
+  mkdirSyncImpl(targetDir, { recursive: true });
+  const extractImpl = tarExtractImpl ?? (await import("tar")).extract;
+  await extractImpl({ file: archive, cwd: targetDir });
+}
+
 async function rpc(creds, name, args, platformFetchImpl) {
   const res = await platformFetchImpl(creds, "/api/query", {
     method: "POST",
@@ -81,12 +95,15 @@ export function createTemplateMarketplaceCommand({
   exitImpl = (code) => process.exit(code),
   infoImpl = info,
   logImpl = log,
+  mkdirSyncImpl = mkdirSync,
   platformFetchImpl = platformFetch,
   readFileSyncImpl = readFileSync,
   requireCredsImpl = requireCreds,
   resolvePathImpl = resolve,
   rmSyncImpl = rmSync,
   successImpl = success,
+  tarCreateImpl,
+  tarExtractImpl,
   writeFileSyncImpl = writeFileSync,
 } = {}) {
   async function publish(options) {
@@ -124,15 +141,18 @@ export function createTemplateMarketplaceCommand({
     });
     if (!outputValidation.ok) throw new Error(outputValidation.error);
 
-    const sourceBundle = createSourceBundle({
+    const sourceBundle = await createSourceBundle({
       cwd,
       staticOutputDir: detection.staticOutputDir,
-      execSyncImpl,
+      mkdirSyncImpl,
+      tarCreateImpl,
     });
-    const staticBundle = createStaticBundle({
+    const staticBundle = await createStaticBundle({
       cwd: resolvePathImpl(cwd, detection.buildWorkdir),
       outputDir: detection.staticOutputDir,
-      execSyncImpl,
+      mkdirSyncImpl,
+      resolvePathImpl,
+      tarCreateImpl,
     });
 
     const creds = requireCredsImpl();
@@ -215,8 +235,11 @@ export function createTemplateMarketplaceCommand({
       const slug = options._[0];
       const dir = options._[1] || slug;
       const archive = await download(slug, { ...options, outFile: ".gencow-template-clone.tar.gz" }, true);
-      execSyncImpl(`mkdir -p ${shellQuote(dir)} && tar -xzf ${shellQuote(archive)} -C ${shellQuote(dir)}`, {
-        cwd: cwdImpl(),
+      await extractTemplateArchive({
+        archive,
+        targetDir: resolvePathImpl(cwdImpl(), dir),
+        mkdirSyncImpl,
+        tarExtractImpl,
       });
       rmSyncImpl(archive, { force: true });
       successImpl(`Cloned into: ${dir}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.165",
+  "version": "0.1.166",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {

package/server/index.js

@@ -117234,6 +117234,7 @@ function createHttpActionRequest(c) {
     params: c.req.param(),
     query: c.req.query(),
     headers: Object.fromEntries(c.req.raw.headers.entries()),
+    raw: c.req.raw,
     json: () => c.req.json(),
     formData: () => c.req.formData(),
     arrayBuffer: () => c.req.arrayBuffer(),