@codemation/cli 0.0.15 → 0.0.18

package/src/dev/ListenPortConflictDescriber.ts

@@ -18,11 +18,7 @@ export class ListenPortConflictDescriber {
       return null;
     }
 
-    const raw = await this.readLsofOutput(port);
-    if (raw === null) {
-      return null;
-    }
-    const occupants = this.parseLsofOutput(raw);
+    const occupants = await this.resolveLoopbackOccupants(port);
     if (occupants.length === 0) {
       return null;
     }
@@ -32,6 +28,22 @@ export class ListenPortConflictDescriber {
       .join("; ");
   }
 
+  private async resolveLoopbackOccupants(port: number): Promise<ReadonlyArray<PortOccupant>> {
+    const lsofRaw = await this.readLsofOutput(port);
+    const fromLsof = lsofRaw !== null ? this.parseLsofOutput(lsofRaw) : [];
+    if (fromLsof.length > 0) {
+      return fromLsof;
+    }
+    if (this.platform !== "linux") {
+      return [];
+    }
+    const ssRaw = await this.readSsOutput(port);
+    if (ssRaw === null) {
+      return [];
+    }
+    return this.parseSsListenOutput(ssRaw, port);
+  }
+
   private async readLsofOutput(port: number): Promise<string | null> {
     try {
       return await new Promise<string>((resolve, reject) => {
@@ -80,4 +92,53 @@ export class ListenPortConflictDescriber {
 
     return occupants;
   }
+
+  private async readSsOutput(port: number): Promise<string | null> {
+    const filtered = await this.execFileStdout("ss", ["-lntp", `sport = :${port}`]);
+    if (filtered !== null && filtered.trim().length > 0) {
+      return filtered;
+    }
+    return this.execFileStdout("ss", ["-lntp"]);
+  }
+
+  private async execFileStdout(command: string, args: readonly string[]): Promise<string | null> {
+    try {
+      return await new Promise<string>((resolve, reject) => {
+        execFile(command, [...args], (error, stdout) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(stdout);
+        });
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  private parseSsListenOutput(raw: string, port: number): ReadonlyArray<PortOccupant> {
+    const occupants: PortOccupant[] = [];
+    const portSuffix = `:${port}`;
+    for (const line of raw.split("\n")) {
+      if (!line.includes("LISTEN") || !line.includes(portSuffix)) {
+        continue;
+      }
+      const pidMatch = line.match(/pid=(\d+)/);
+      if (!pidMatch) {
+        continue;
+      }
+      const pid = Number.parseInt(pidMatch[1] ?? "0", 10);
+      const cmdMatch = line.match(/users:\(\("([^"]*)"/);
+      const command = cmdMatch?.[1] ?? "unknown";
+      const localAddrMatch = line.match(/\s+(\S+:\d+|\[[^\]]+\]:\d+)\s+/);
+      const endpoint = localAddrMatch?.[1] ?? `tcp:${String(port)}`;
+      occupants.push({
+        pid,
+        command,
+        endpoint,
+      });
+    }
+    return occupants;
+  }
 }

package/src/dev/{DevAuthSettingsLoader.ts → NextHostEdgeSeedLoader.ts}

@@ -4,13 +4,12 @@ import { CodemationConsumerConfigLoader } from "@codemation/host/server";
 
 import type { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 
-export type DevResolvedAuthSettings = Readonly<{
-  authConfigJson: string;
+export type NextHostEdgeSeed = Readonly<{
   authSecret: string;
-  skipUiAuth: boolean;
+  uiAuthEnabled: boolean;
 }>;
 
-export class DevAuthSettingsLoader {
+export class NextHostEdgeSeedLoader {
   static readonly defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
 
   constructor(
@@ -25,13 +24,18 @@ export class DevAuthSettingsLoader {
     return randomUUID();
   }
 
-  async loadForConsumer(consumerRoot: string): Promise<DevResolvedAuthSettings> {
-    const resolution = await this.configLoader.load({ consumerRoot });
+  async loadForConsumer(
+    consumerRoot: string,
+    options?: Readonly<{ configPathOverride?: string }>,
+  ): Promise<NextHostEdgeSeed> {
+    const resolution = await this.configLoader.load({
+      consumerRoot,
+      configPathOverride: options?.configPathOverride,
+    });
     const envForAuthSecret = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(consumerRoot, process.env);
     return {
-      authConfigJson: JSON.stringify(resolution.config.auth ?? null),
       authSecret: this.resolveDevelopmentAuthSecret(envForAuthSecret),
-      skipUiAuth: resolution.config.auth?.allowUnauthenticatedInDevelopment === true,
+      uiAuthEnabled: resolution.config.auth?.allowUnauthenticatedInDevelopment !== true,
     };
   }
 
@@ -40,6 +44,6 @@ export class DevAuthSettingsLoader {
     if (configuredSecret && configuredSecret.trim().length > 0) {
       return configuredSecret;
     }
-    return DevAuthSettingsLoader.defaultDevelopmentAuthSecret;
+    return NextHostEdgeSeedLoader.defaultDevelopmentAuthSecret;
   }
 }

package/src/dev/PluginDevConfigFactory.ts

@@ -0,0 +1,64 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export type PluginDevConfigBootstrap = Readonly<{
+  configPath: string;
+}>;
+
+export class PluginDevConfigFactory {
+  async prepare(pluginRoot: string): Promise<PluginDevConfigBootstrap> {
+    const pluginEntryPath = await this.resolvePluginEntryPath(pluginRoot);
+    const configPath = path.resolve(pluginRoot, ".codemation", "plugin-dev", "codemation.config.ts");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, this.createConfigSource(configPath, pluginEntryPath), "utf8");
+    return {
+      configPath,
+    };
+  }
+
+  private async resolvePluginEntryPath(pluginRoot: string): Promise<string> {
+    const candidates = [
+      path.resolve(pluginRoot, "codemation.plugin.ts"),
+      path.resolve(pluginRoot, "codemation.plugin.js"),
+      path.resolve(pluginRoot, "src", "codemation.plugin.ts"),
+      path.resolve(pluginRoot, "src", "codemation.plugin.js"),
+    ];
+    for (const candidate of candidates) {
+      if (await this.exists(candidate)) {
+        return candidate;
+      }
+    }
+    throw new Error('Plugin config not found. Expected "codemation.plugin.ts" in the plugin root or "src/".');
+  }
+
+  private createConfigSource(configPath: string, pluginEntryPath: string): string {
+    const relativeImportPath = this.toRelativeImportPath(configPath, pluginEntryPath);
+    return [
+      'import type { CodemationConfig } from "@codemation/host";',
+      `import plugin from ${JSON.stringify(relativeImportPath)};`,
+      "",
+      "const sandbox = plugin.sandbox ?? {};",
+      "const config: CodemationConfig = {",
+      "  ...sandbox,",
+      "  plugins: [...(sandbox.plugins ?? []), plugin],",
+      "};",
+      "",
+      "export default config;",
+      "",
+    ].join("\n");
+  }
+
+  private toRelativeImportPath(fromPath: string, targetPath: string): string {
+    const relativePath = path.relative(path.dirname(fromPath), targetPath).replace(/\\/g, "/");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+
+  private async exists(filePath: string): Promise<boolean> {
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/consumer/Loader.ts

@@ -1,8 +0,0 @@
-import type { ConsumerBuildOptions } from "./consumerBuildOptions.types";
-import { ConsumerOutputBuilder } from "./ConsumerOutputBuilder";
-
-export class ConsumerOutputBuilderLoader {
-  create(consumerRoot: string, buildOptions: ConsumerBuildOptions): ConsumerOutputBuilder {
-    return new ConsumerOutputBuilder(consumerRoot, undefined, buildOptions);
-  }
-}

package/src/dev/DevConsumerPublishBootstrap.ts

@@ -1,30 +0,0 @@
-import type { Logger } from "@codemation/host/next/server";
-import { CodemationPluginDiscovery } from "@codemation/host/server";
-
-import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
-import { ConsumerBuildOptionsParser } from "../build/ConsumerBuildOptionsParser";
-import { ConsumerOutputBuilderLoader } from "../consumer/Loader";
-import type { CliPaths } from "../path/CliPathResolver";
-
-/**
- * Ensures `.codemation/output/current.json` and transpiled consumer config exist before the Next host boots.
- * Without this, `codemation dev` can serve a stale built `codemation.config.js` (e.g. missing whitelabel).
- */
-export class DevConsumerPublishBootstrap {
-  constructor(
-    private readonly cliLogger: Logger,
-    private readonly pluginDiscovery: CodemationPluginDiscovery,
-    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
-    private readonly outputBuilderLoader: ConsumerOutputBuilderLoader,
-    private readonly buildOptionsParser: ConsumerBuildOptionsParser,
-  ) {}
-
-  async ensurePublished(paths: CliPaths): Promise<void> {
-    const buildOptions = this.buildOptionsParser.parse({});
-    const builder = this.outputBuilderLoader.create(paths.consumerRoot, buildOptions);
-    const snapshot = await builder.ensureBuilt();
-    const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
-    await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
-    this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
-  }
-}