@rikalabs/logpoint 0.0.2

package/src/collector.ts

@@ -0,0 +1,192 @@
+import { appendFile } from "node:fs/promises";
+import { Duration, Effect } from "effect";
+import { optionalNumberOption, optionalStringOption, parseArgs } from "./lib/cli-args.js";
+import { CollectorTimeout, ManifestError, PortInUse, ValidationError } from "./lib/errors.js";
+import { decodeCollectorConfigUnknown, decodeSnapshotUnknown, type CollectorConfig } from "./lib/schema.js";
+import { AppLive, FileSystem, Logger } from "./lib/services.js";
+
+const defaultPortFile = "/tmp/debug-logpoints.port";
+const defaultPidFile = "/tmp/debug-logpoints.pid";
+
+const isPortInUseError = (cause: unknown): boolean => {
+  const message = String(cause).toLowerCase();
+  return message.includes("address already in use") || message.includes("eaddrinuse");
+};
+
+const corsHeaders = (origin: string): Record<string, string> => ({
+  "Access-Control-Allow-Origin": origin,
+  "Access-Control-Allow-Methods": "POST,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type",
+  "Content-Type": "application/json",
+});
+
+const parseCollectorConfig = (argv: readonly string[]) =>
+  Effect.gen(function* () {
+    const parsed = parseArgs(argv);
+    const port = yield* optionalNumberOption(parsed, "port");
+    const timeout = yield* optionalNumberOption(parsed, "timeout");
+    const output = yield* optionalStringOption(parsed, "output");
+    const corsOrigin = yield* optionalStringOption(parsed, "cors-origin");
+
+    return yield* decodeCollectorConfigUnknown({
+      port,
+      timeout,
+      output,
+      corsOrigin,
+    });
+  });
+
+const startServer = (
+  port: number,
+  config: CollectorConfig,
+  hits: Map<string, number>,
+): Effect.Effect<Bun.Server<unknown>, PortInUse | ManifestError, never> =>
+  Effect.try({
+    try: () =>
+      Bun.serve({
+        port,
+        fetch: async (request: Request): Promise<Response> => {
+          if (request.method === "OPTIONS") {
+            return new Response(null, { status: 204, headers: corsHeaders(config.corsOrigin) });
+          }
+
+          if (request.method !== "POST") {
+            return new Response(JSON.stringify({ ok: false, error: "Method not allowed" }), {
+              status: 405,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          }
+
+          let body: unknown;
+          try {
+            body = (await request.json()) as unknown;
+          } catch {
+            return new Response(JSON.stringify({ ok: false, error: "Invalid JSON" }), {
+              status: 400,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          }
+
+          const decoded = await Effect.runPromise(decodeSnapshotUnknown(body).pipe(Effect.either));
+          if (decoded._tag === "Left") {
+            return new Response(JSON.stringify({ ok: false, error: decoded.left.message }), {
+              status: 400,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          }
+
+          const snapshot = decoded.right;
+          const count = (hits.get(snapshot.id) ?? 0) + 1;
+          hits.set(snapshot.id, count);
+
+          const maxHits = snapshot.maxHits;
+          if (maxHits !== undefined && count > maxHits) {
+            return new Response(JSON.stringify({ ok: true, skipped: true }), {
+              status: 202,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          }
+
+          const enriched = {
+            ...snapshot,
+            hit: snapshot.hit ?? count,
+            _receivedAt: new Date().toISOString(),
+          };
+
+          try {
+            const line = JSON.stringify(enriched);
+            await appendFile(config.output, `${line}\n`, "utf8");
+            console.log(line);
+            return new Response(JSON.stringify({ ok: true }), {
+              status: 200,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          } catch (cause) {
+            return new Response(JSON.stringify({ ok: false, error: String(cause) }), {
+              status: 500,
+              headers: corsHeaders(config.corsOrigin),
+            });
+          }
+        },
+      }),
+    catch: (cause) => {
+      if (isPortInUseError(cause)) {
+        return new PortInUse({ port });
+      }
+      return new ManifestError({
+        message: `Failed to start collector on port ${port}`,
+        cause,
+      });
+    },
+  });
+
+export const runCollector = (
+  config: CollectorConfig,
+): Effect.Effect<void, ManifestError | PortInUse | CollectorTimeout | ValidationError, FileSystem | Logger> =>
+  Effect.gen(function* () {
+    const logger = yield* Logger;
+    const fs = yield* FileSystem;
+    const hits = new Map<string, number>();
+
+    let server: Bun.Server<unknown> | undefined;
+    let boundPort = config.port;
+
+    for (let attempt = 0; attempt <= 10; attempt += 1) {
+      const port = config.port + attempt;
+      const started = yield* startServer(port, config, hits).pipe(Effect.either);
+      if (started._tag === "Right") {
+        server = started.right;
+        boundPort = port;
+        break;
+      }
+
+      if (started.left._tag !== "PortInUse" || attempt === 10) {
+        return yield* Effect.fail(started.left);
+      }
+    }
+
+    if (server === undefined) {
+      return yield* Effect.fail(new ManifestError({ message: "Collector failed to start", cause: "no server" }));
+    }
+
+    yield* fs.writeFile(defaultPortFile, String(boundPort)).pipe(
+      Effect.mapError((error) => new ManifestError({ message: error.message, cause: error })),
+    );
+    yield* fs.writeFile(defaultPidFile, String(process.pid)).pipe(
+      Effect.mapError((error) => new ManifestError({ message: error.message, cause: error })),
+    );
+
+    yield* logger.info(
+      `collector listening on http://localhost:${boundPort} output=${config.output} timeout=${config.timeout}s`,
+    );
+
+    yield* Effect.sleep(Duration.seconds(config.timeout));
+    server.stop(true);
+    yield* fs.removeFile(defaultPidFile).pipe(Effect.catchAll(() => Effect.void));
+
+    return yield* Effect.fail(new CollectorTimeout({ seconds: config.timeout }));
+  });
+
+export const runCollectorFromArgs = (
+  argv: readonly string[],
+): Effect.Effect<void, ManifestError | PortInUse | CollectorTimeout | ValidationError, FileSystem | Logger> =>
+  parseCollectorConfig(argv).pipe(Effect.flatMap((config) => runCollector(config)));
+
+const execute = (argv: readonly string[]): Promise<void> =>
+  Effect.runPromise(
+    runCollectorFromArgs(argv).pipe(
+      Effect.provide(AppLive),
+      Effect.catchTag("CollectorTimeout", (error) =>
+        Effect.sync(() => {
+          console.error(error.message);
+        }),
+      ),
+    ),
+  );
+
+if (import.meta.main) {
+  execute(Bun.argv.slice(2)).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}

package/src/doctor.ts

@@ -0,0 +1,63 @@
+import { createServer } from "node:net";
+import { Effect } from "effect";
+import { AppLive, FileSystem, Logger, RuntimeEnv } from "./lib/services.js";
+
+const checkPort = (port: number): Effect.Effect<boolean, never, never> =>
+  Effect.async<boolean>((resume) => {
+    const server = createServer();
+
+    server.once("error", () => {
+      resume(Effect.succeed(false));
+    });
+
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => {
+        resume(Effect.succeed(true));
+      });
+    });
+
+    return Effect.sync(() => {
+      server.close();
+    });
+  });
+
+export const runDoctorFromArgs = (): Effect.Effect<void, never, FileSystem | Logger | RuntimeEnv> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const logger = yield* Logger;
+    const env = yield* RuntimeEnv;
+
+    const probePath = `${env.tmpDir.replace(/\/$/, "")}/logpoint-doctor-${Date.now()}.tmp`;
+
+    const writable = yield* fs
+      .writeFile(probePath, "ok")
+      .pipe(
+        Effect.flatMap(() => fs.removeFile(probePath)),
+        Effect.map(() => true),
+        Effect.catchAll(() => Effect.succeed(false)),
+      );
+
+    const port9111Free = yield* checkPort(9111);
+
+    yield* logger.info(
+      JSON.stringify(
+        {
+          runtime: "bun",
+          bunVersion: Bun.version,
+          cwd: env.cwd,
+          tmpDir: env.tmpDir,
+          tmpWritable: writable,
+          port9111Available: port9111Free,
+        },
+        null,
+        2,
+      ),
+    );
+  });
+
+if (import.meta.main) {
+  Effect.runPromise(runDoctorFromArgs().pipe(Effect.provide(AppLive))).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}

package/src/inject.ts

@@ -0,0 +1,168 @@
+import { resolve } from "node:path";
+import { Effect } from "effect";
+import {
+  optionalBooleanOption,
+  optionalStringOption,
+  parseArgs,
+  requireStringOption,
+} from "./lib/cli-args.js";
+import {
+  InjectionError,
+  ManifestError,
+  ValidationError,
+  type FileNotFound,
+  type FileReadError,
+  type FileWriteError,
+  type ParseError,
+} from "./lib/errors.js";
+import { injectContent } from "./lib/injection-engine.js";
+import { isLanguage } from "./lib/language.js";
+import {
+  decodeInjectConfigUnknown,
+  decodeManifestUnknown,
+  parseJsonString,
+  type InjectConfig,
+  type LogpointDef,
+  type Manifest,
+} from "./lib/schema.js";
+import { AppLive, FileSystem, Logger } from "./lib/services.js";
+
+const parseInjectConfig = (argv: readonly string[]): Effect.Effect<InjectConfig, ManifestError | ValidationError, never> =>
+  Effect.gen(function* () {
+    const parsed = parseArgs(argv);
+    const manifestFromArg = parsed.positionals[0];
+    const manifestFromOption = yield* optionalStringOption(parsed, "manifest");
+    const manifest = manifestFromOption ?? manifestFromArg;
+
+    if (manifest === undefined) {
+      return yield* requireStringOption(parsed, "manifest").pipe(
+        Effect.mapError((error) => new ManifestError({ message: error.message, cause: error })),
+        Effect.as(undefined as never),
+      );
+    }
+
+    const projectRoot = yield* optionalStringOption(parsed, "project-root");
+    const dryRun = yield* optionalBooleanOption(parsed, "dry-run");
+    const languageRaw = yield* optionalStringOption(parsed, "language");
+
+    if (languageRaw !== undefined && !isLanguage(languageRaw)) {
+      return yield* Effect.fail(
+        new ValidationError({
+          message: `Unsupported language: ${languageRaw}`,
+        }),
+      );
+    }
+
+    return yield* decodeInjectConfigUnknown({
+      manifest,
+      projectRoot,
+      dryRun,
+      language: languageRaw,
+    });
+  });
+
+const groupByFile = (
+  manifest: Manifest,
+  root: string,
+): ReadonlyMap<string, readonly LogpointDef[]> => {
+  const grouped = new Map<string, LogpointDef[]>();
+  for (const logpoint of manifest.logpoints) {
+    const absolutePath = resolve(root, logpoint.file);
+    const current = grouped.get(absolutePath) ?? [];
+    current.push(logpoint);
+    grouped.set(absolutePath, current);
+  }
+
+  return grouped;
+};
+
+export type InjectRunError =
+  | ManifestError
+  | ValidationError
+  | InjectionError
+  | FileNotFound
+  | FileReadError
+  | FileWriteError
+  | ParseError;
+
+export const runInject = (
+  config: InjectConfig,
+): Effect.Effect<void, InjectRunError, FileSystem | Logger> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const logger = yield* Logger;
+
+    const manifestContent = yield* fs.readFile(config.manifest);
+    const manifestJson = yield* parseJsonString(manifestContent);
+    const manifest = yield* decodeManifestUnknown(manifestJson);
+
+    const root = resolve(config.projectRoot ?? manifest.projectRoot);
+    const grouped = groupByFile(manifest, root);
+
+    const entries = [...grouped.entries()];
+
+    const results = yield* Effect.forEach(
+      entries,
+      ([filePath, defs]) =>
+        Effect.gen(function* () {
+          const original = yield* fs.readFile(filePath);
+
+          const injected = yield* injectContent(
+            original,
+            defs,
+            filePath,
+            manifest.port,
+            config.language ?? manifest.language,
+          );
+
+          for (const blocked of injected.blocked) {
+            yield* logger.warn(blocked.message);
+          }
+
+          if (!config.dryRun && injected.inserted > 0 && original !== injected.content) {
+            yield* fs.writeFile(filePath, injected.content);
+          }
+
+          return {
+            filePath,
+            inserted: injected.inserted,
+            blocked: injected.blocked.length,
+            dryRun: config.dryRun,
+          };
+        }),
+      { concurrency: 8 },
+    );
+
+    const summary = {
+      files: results.length,
+      inserted: results.reduce((total, item) => total + item.inserted, 0),
+      blocked: results.reduce((total, item) => total + item.blocked, 0),
+      dryRun: config.dryRun,
+      manifest: config.manifest,
+    };
+
+    yield* logger.json(summary);
+
+    if (config.dryRun) {
+      for (const item of results) {
+        if (item.inserted > 0) {
+          yield* logger.info(`dry-run would inject ${item.inserted} logpoints in ${item.filePath}`);
+        }
+      }
+    }
+  });
+
+export const runInjectFromArgs = (
+  argv: readonly string[],
+): Effect.Effect<void, InjectRunError, FileSystem | Logger> =>
+  parseInjectConfig(argv).pipe(Effect.flatMap((config) => runInject(config)));
+
+const execute = (argv: readonly string[]): Promise<void> =>
+  Effect.runPromise(runInjectFromArgs(argv).pipe(Effect.provide(AppLive)));
+
+if (import.meta.main) {
+  execute(Bun.argv.slice(2)).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}

package/src/lib/cli-args.ts

@@ -0,0 +1,140 @@
+import { Effect } from "effect";
+import { ValidationError } from "./errors.js";
+
+export type ParsedArgs = {
+  readonly positionals: readonly string[];
+  readonly options: Readonly<Record<string, string | boolean>>;
+};
+
+export const parseArgs = (argv: readonly string[]): ParsedArgs => {
+  const positionals: string[] = [];
+  const options: Record<string, string | boolean> = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === undefined) {
+      continue;
+    }
+
+    if (!token.startsWith("-")) {
+      positionals.push(token);
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      const raw = token.slice(2);
+      if (raw.length === 0) {
+        continue;
+      }
+
+      const equalsIndex = raw.indexOf("=");
+      if (equalsIndex >= 0) {
+        const key = raw.slice(0, equalsIndex);
+        const value = raw.slice(equalsIndex + 1);
+        options[key] = value;
+        continue;
+      }
+
+      const next = argv[index + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        options[raw] = next;
+        index += 1;
+      } else {
+        options[raw] = true;
+      }
+      continue;
+    }
+
+    const shortFlags = token.slice(1);
+    if (shortFlags.length === 0) {
+      continue;
+    }
+
+    for (const flag of shortFlags) {
+      options[flag] = true;
+    }
+  }
+
+  return { positionals, options };
+};
+
+const getOption = (parsed: ParsedArgs, key: string): string | boolean | undefined => parsed.options[key];
+
+export const requireStringOption = (
+  parsed: ParsedArgs,
+  key: string,
+): Effect.Effect<string, ValidationError, never> => {
+  const value = getOption(parsed, key);
+  if (typeof value === "string" && value.length > 0) {
+    return Effect.succeed(value);
+  }
+  return Effect.fail(new ValidationError({ message: `Missing required option --${key}` }));
+};
+
+export const optionalStringOption = (
+  parsed: ParsedArgs,
+  key: string,
+): Effect.Effect<string | undefined, never, never> => {
+  const value = getOption(parsed, key);
+  if (typeof value === "string") {
+    return Effect.succeed(value);
+  }
+  return Effect.succeed(undefined);
+};
+
+export const optionalBooleanOption = (
+  parsed: ParsedArgs,
+  key: string,
+): Effect.Effect<boolean | undefined, never, never> => {
+  const value = getOption(parsed, key);
+  if (typeof value === "boolean") {
+    return Effect.succeed(value);
+  }
+  if (typeof value === "string") {
+    if (value === "true") {
+      return Effect.succeed(true);
+    }
+    if (value === "false") {
+      return Effect.succeed(false);
+    }
+  }
+  return Effect.succeed(undefined);
+};
+
+export const optionalNumberOption = (
+  parsed: ParsedArgs,
+  key: string,
+): Effect.Effect<number | undefined, ValidationError, never> => {
+  const value = getOption(parsed, key);
+  if (value === undefined) {
+    return Effect.succeed(undefined);
+  }
+  if (typeof value === "boolean") {
+    return Effect.fail(new ValidationError({ message: `Option --${key} requires a number` }));
+  }
+
+  const parsedValue = Number(value);
+  if (Number.isNaN(parsedValue)) {
+    return Effect.fail(new ValidationError({ message: `Option --${key} is not a valid number` }));
+  }
+
+  return Effect.succeed(parsedValue);
+};
+
+export const optionalCsvOption = (
+  parsed: ParsedArgs,
+  key: string,
+): Effect.Effect<readonly string[] | undefined, never, never> => {
+  const value = getOption(parsed, key);
+  if (typeof value !== "string") {
+    return Effect.succeed(undefined);
+  }
+  const items = value
+    .split(",")
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+  if (items.length === 0) {
+    return Effect.succeed(undefined);
+  }
+  return Effect.succeed(items);
+};

package/src/lib/errors.ts

@@ -0,0 +1,108 @@
+import { Data } from "effect";
+
+export class FileNotFound extends Data.TaggedError("FileNotFound")<{
+  readonly path: string;
+}> {
+  override get message(): string {
+    return `File not found: ${this.path}`;
+  }
+}
+
+export class FileReadError extends Data.TaggedError("FileReadError")<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {
+  override get message(): string {
+    return `Failed to read file ${this.path}: ${String(this.cause)}`;
+  }
+}
+
+export class FileWriteError extends Data.TaggedError("FileWriteError")<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {
+  override get message(): string {
+    return `Failed to write file ${this.path}: ${String(this.cause)}`;
+  }
+}
+
+export class ParseError extends Data.TaggedError("ParseError")<{
+  readonly input: string;
+  readonly cause: unknown;
+}> {
+  override get message(): string {
+    return `Failed to parse input: ${this.input} (${String(this.cause)})`;
+  }
+}
+
+export class ManifestError extends Data.TaggedError("ManifestError")<{
+  readonly message: string;
+  readonly cause: unknown;
+}> {}
+
+export class ValidationError extends Data.TaggedError("ValidationError")<{
+  readonly message: string;
+}> {}
+
+export class PortInUse extends Data.TaggedError("PortInUse")<{
+  readonly port: number;
+}> {
+  override get message(): string {
+    return `Port is in use: ${this.port}`;
+  }
+}
+
+export class InjectionError extends Data.TaggedError("InjectionError")<{
+  readonly logpointId: string;
+  readonly file: string;
+  readonly line: number;
+  readonly reason: string;
+}> {
+  override get message(): string {
+    return `Injection failed for ${this.logpointId} at ${this.file}:${this.line} - ${this.reason}`;
+  }
+}
+
+export class CleanupError extends Data.TaggedError("CleanupError")<{
+  readonly file: string;
+  readonly reason: string;
+}> {
+  override get message(): string {
+    return `Cleanup failed for ${this.file}: ${this.reason}`;
+  }
+}
+
+export class SecretVarBlocked extends Data.TaggedError("SecretVarBlocked")<{
+  readonly logpointId: string;
+  readonly variable: string;
+}> {
+  override get message(): string {
+    return `Blocked secret variable ${this.variable} in ${this.logpointId}`;
+  }
+}
+
+export class CollectorTimeout extends Data.TaggedError("CollectorTimeout")<{
+  readonly seconds: number;
+}> {
+  override get message(): string {
+    return `Collector timeout reached after ${this.seconds} seconds`;
+  }
+}
+
+export class CliUsageError extends Data.TaggedError("CliUsageError")<{
+  readonly message: string;
+}> {}
+
+export type LogpointError =
+  | FileNotFound
+  | FileReadError
+  | FileWriteError
+  | ParseError
+  | ManifestError
+  | ValidationError
+  | PortInUse
+  | InjectionError
+  | CleanupError
+  | SecretVarBlocked
+  | CollectorTimeout
+  | CliUsageError;