srcpack 0.1.0

package/src/cli.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env bun
+// SPDX-License-Identifier: MIT
+
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { bundleOne, type BundleResult } from "./bundle.ts";
+import { loadConfig, type BundleConfig, type UploadConfig } from "./config.ts";
+import { ensureAuthenticated, login, OAuthError } from "./gdrive.ts";
+import { runInit } from "./init.ts";
+
+interface BundleOutput {
+  name: string;
+  outfile: string;
+  result: BundleResult;
+}
+
+function sumLines(result: BundleResult): number {
+  return result.index.reduce((sum, entry) => sum + entry.lines, 0);
+}
+
+function formatNumber(n: number): string {
+  return n.toLocaleString("en-US");
+}
+
+function plural(n: number, singular: string, pluralForm?: string): string {
+  return n === 1 ? singular : (pluralForm ?? singular + "s");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+srcpack - Bundle and upload tool
+
+Usage:
+  npx srcpack              Bundle all, upload if configured
+  npx srcpack web api      Bundle specific bundles only
+  npx srcpack --dry-run    Bundle without upload (preview)
+  npx srcpack --init       Interactive config setup
+  npx srcpack login        Authenticate with Google Drive
+
+Options:
+  --dry-run    Preview bundles without uploading
+  --init       Create configuration file
+  -h, --help   Show this help message
+`);
+    return;
+  }
+
+  if (args.includes("--init")) {
+    await runInit();
+    return;
+  }
+
+  if (args.includes("login")) {
+    await runLogin();
+    return;
+  }
+
+  const dryRun = args.includes("--dry-run");
+  const requestedBundles = args.filter((arg) => !arg.startsWith("-"));
+
+  const config = await loadConfig();
+
+  if (!config) {
+    console.error(
+      "No configuration found. Run `npx srcpack --init` to create one.",
+    );
+    process.exit(1);
+  }
+
+  // Determine which bundles to process
+  const bundleNames = requestedBundles.length
+    ? requestedBundles
+    : Object.keys(config.bundles);
+
+  // Validate requested bundle names exist
+  for (const name of bundleNames) {
+    if (!(name in config.bundles)) {
+      console.error(`Unknown bundle: ${name}`);
+      process.exit(1);
+    }
+  }
+
+  if (bundleNames.length === 0) {
+    console.log("No bundles configured.");
+    return;
+  }
+
+  const cwd = process.cwd();
+  const outputs: BundleOutput[] = [];
+
+  // Process all bundles
+  for (const name of bundleNames) {
+    const bundleConfig = config.bundles[name]!;
+    const result = await bundleOne(name, bundleConfig, cwd);
+    const outfile = getOutfile(bundleConfig, name, config.outDir);
+    outputs.push({ name, outfile, result });
+  }
+
+  // Calculate column widths for aligned output
+  const maxNameLen = Math.max(...outputs.map((o) => o.name.length));
+  const maxFilesLen = Math.max(
+    ...outputs.map((o) => formatNumber(o.result.index.length).length),
+  );
+  const maxLinesLen = Math.max(
+    ...outputs.map((o) => formatNumber(sumLines(o.result)).length),
+  );
+
+  // Print each bundle
+  console.log();
+  for (const { name, outfile, result } of outputs) {
+    const fileCount = result.index.length;
+    const lineCount = sumLines(result);
+    const outPath = join(cwd, outfile);
+
+    const nameCol = name.padEnd(maxNameLen);
+    const filesCol = formatNumber(fileCount).padStart(maxFilesLen);
+    const linesCol = formatNumber(lineCount).padStart(maxLinesLen);
+
+    if (dryRun) {
+      console.log(
+        `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}`,
+      );
+      for (const entry of result.index) {
+        console.log(`    ${entry.path}`);
+      }
+    } else {
+      await mkdir(dirname(outPath), { recursive: true });
+      await Bun.write(outPath, result.content);
+      console.log(
+        `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → ${outfile}`,
+      );
+    }
+  }
+
+  // Print summary
+  const totalFiles = outputs.reduce((sum, o) => sum + o.result.index.length, 0);
+  const totalLines = outputs.reduce((sum, o) => sum + sumLines(o.result), 0);
+  const bundleWord = plural(outputs.length, "bundle");
+  const fileWord = plural(totalFiles, "file");
+  const lineWord = plural(totalLines, "line");
+
+  console.log();
+  if (dryRun) {
+    console.log(
+      `Dry run: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
+    );
+  } else {
+    console.log(
+      `Done: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
+    );
+
+    // Handle upload if configured
+    if (config.upload) {
+      const uploads = Array.isArray(config.upload)
+        ? config.upload
+        : [config.upload];
+
+      for (const uploadConfig of uploads) {
+        if (isGdriveConfigured(uploadConfig)) {
+          await handleGdriveUpload(uploadConfig, outputs);
+        }
+      }
+    }
+  }
+}
+
+function isGdriveConfigured(config: UploadConfig): boolean {
+  return (
+    config.provider === "gdrive" &&
+    Boolean(config.clientId) &&
+    Boolean(config.clientSecret)
+  );
+}
+
+function getGdriveConfig(config: {
+  upload?: UploadConfig | UploadConfig[];
+}): UploadConfig | null {
+  if (!config.upload) return null;
+  const uploads = Array.isArray(config.upload)
+    ? config.upload
+    : [config.upload];
+  return uploads.find(isGdriveConfigured) ?? null;
+}
+
+async function runLogin(): Promise<void> {
+  const config = await loadConfig();
+
+  if (!config) {
+    console.error(
+      "No configuration found. Run `npx srcpack --init` to create one.",
+    );
+    process.exit(1);
+  }
+
+  const uploadConfig = getGdriveConfig(config);
+  if (!uploadConfig) {
+    console.error("No Google Drive upload configured.");
+    console.error(
+      "Add upload config with clientId and clientSecret to your srcpack.config.ts",
+    );
+    process.exit(1);
+  }
+
+  try {
+    console.log("Opening browser for authentication...");
+    await login(uploadConfig);
+    console.log("Login successful. Tokens saved to ~/.srcpack/tokens.json");
+  } catch (error) {
+    if (error instanceof OAuthError) {
+      console.error(`OAuth error: ${error.error}`);
+      if (error.error_description) {
+        console.error(`  ${error.error_description}`);
+      }
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function handleGdriveUpload(
+  uploadConfig: UploadConfig,
+  _outputs: BundleOutput[],
+): Promise<void> {
+  try {
+    await ensureAuthenticated(uploadConfig);
+
+    // TODO: Upload bundles to Google Drive using tokens
+    console.log();
+    console.log("Authenticated with Google Drive.");
+    if (uploadConfig.folder) {
+      console.log(`Ready to upload to folder: ${uploadConfig.folder}`);
+    }
+  } catch (error) {
+    if (error instanceof OAuthError) {
+      console.error(`OAuth error: ${error.error}`);
+      if (error.error_description) {
+        console.error(`  ${error.error_description}`);
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+
+function getOutfile(
+  bundleConfig: BundleConfig,
+  name: string,
+  outDir: string,
+): string {
+  if (
+    typeof bundleConfig === "object" &&
+    !Array.isArray(bundleConfig) &&
+    bundleConfig.outfile
+  ) {
+    return bundleConfig.outfile;
+  }
+  return join(outDir, `${name}.txt`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { cosmiconfig } from "cosmiconfig";
+import { z } from "zod";
+
+export function expandPath(p: string): string {
+  if (p.startsWith("~/")) {
+    return join(homedir(), p.slice(2));
+  }
+  return p;
+}
+
+const PatternsSchema = z.union([
+  z.string().min(1),
+  z.array(z.string().min(1)).min(1),
+]);
+
+const BundleConfigSchema = z.union([
+  z.string().min(1), // "src/**/*"
+  z.array(z.string().min(1)).min(1), // ["src/**/*", "!src/specs"]
+  z.object({
+    include: PatternsSchema,
+    outfile: z.string().optional(),
+    index: z.boolean().default(true), // Include index header in output
+  }),
+]);
+
+const UploadConfigSchema = z.object({
+  provider: z.literal("gdrive"),
+  folder: z.string().optional(),
+  clientId: z.string().min(1),
+  clientSecret: z.string().min(1),
+});
+
+const ConfigSchema = z.object({
+  outDir: z.string().default(".srcpack"),
+  upload: z
+    .union([UploadConfigSchema, z.array(UploadConfigSchema).min(1)])
+    .optional(),
+  bundles: z.record(z.string(), BundleConfigSchema),
+});
+
+export type UploadConfig = z.infer<typeof UploadConfigSchema>;
+export type BundleConfig = z.infer<typeof BundleConfigSchema>;
+export type BundleConfigInput = z.input<typeof BundleConfigSchema>;
+export type Config = z.infer<typeof ConfigSchema>;
+export type ConfigInput = z.input<typeof ConfigSchema>;
+
+export function defineConfig(config: ConfigInput): ConfigInput {
+  return config;
+}
+
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
+
+export function parseConfig(value: unknown): Config {
+  const result = ConfigSchema.safeParse(value);
+  if (!result.success) {
+    const issue = result.error.issues[0]!;
+    const path = issue.path.join(".");
+    const message = path ? `${path}: ${issue.message}` : issue.message;
+    throw new ConfigError(message);
+  }
+
+  const config = result.data;
+  config.outDir = expandPath(config.outDir);
+
+  for (const bundle of Object.values(config.bundles)) {
+    if (
+      typeof bundle === "object" &&
+      !Array.isArray(bundle) &&
+      bundle.outfile
+    ) {
+      bundle.outfile = expandPath(bundle.outfile);
+    }
+  }
+
+  return config;
+}
+
+const explorer = cosmiconfig("srcpack", {
+  searchPlaces: [
+    "srcpack.config.ts", // Primary: full TypeScript support with Bun
+    "srcpack.config.js", // Fallback for JS-only projects
+    "package.json", // Zero-file option via "srcpack" field
+  ],
+});
+
+export async function loadConfig(searchFrom?: string): Promise<Config | null> {
+  const result = await explorer.search(searchFrom);
+  if (!result) return null;
+  return parseConfig(result.config);
+}
+
+export async function loadConfigFromFile(
+  filepath: string,
+): Promise<Config | null> {
+  const result = await explorer.load(filepath);
+  if (!result) return null;
+  return parseConfig(result.config);
+}

package/src/gdrive.ts

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: MIT
+
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { getAuthCode, OAuthError } from "oauth-callback";
+import type { UploadConfig } from "./config.ts";
+
+const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const SCOPES = ["https://www.googleapis.com/auth/drive.file"];
+const REDIRECT_URI = "http://localhost:3000/callback";
+const TOKENS_PATH = join(homedir(), ".srcpack", "tokens.json");
+
+export interface Tokens {
+  access_token: string;
+  refresh_token?: string;
+  expires_at?: number; // Unix timestamp in ms
+  token_type: string;
+  scope: string;
+}
+
+interface TokenResponse {
+  access_token: string;
+  refresh_token?: string;
+  expires_in: number;
+  token_type: string;
+  scope: string;
+}
+
+/**
+ * Loads stored tokens from disk.
+ * Returns null if no tokens exist or they cannot be read.
+ */
+export async function loadTokens(): Promise<Tokens | null> {
+  try {
+    const data = await readFile(TOKENS_PATH, "utf-8");
+    return JSON.parse(data) as Tokens;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Saves tokens to disk for later use.
+ */
+async function saveTokens(tokens: Tokens): Promise<void> {
+  await mkdir(dirname(TOKENS_PATH), { recursive: true });
+  await writeFile(TOKENS_PATH, JSON.stringify(tokens, null, 2));
+}
+
+/**
+ * Removes stored tokens from disk.
+ */
+export async function clearTokens(): Promise<void> {
+  try {
+    await unlink(TOKENS_PATH);
+  } catch {
+    // Ignore if file doesn't exist
+  }
+}
+
+/**
+ * Checks if tokens are expired or about to expire (within 5 minutes).
+ */
+function isExpired(tokens: Tokens): boolean {
+  if (!tokens.expires_at) return false;
+  const buffer = 5 * 60 * 1000; // 5 minutes
+  return Date.now() >= tokens.expires_at - buffer;
+}
+
+/**
+ * Refreshes an expired access token using the refresh token.
+ */
+async function refreshAccessToken(
+  refreshToken: string,
+  config: UploadConfig,
+): Promise<Tokens> {
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      refresh_token: refreshToken,
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      grant_type: "refresh_token",
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${error}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  const tokens: Tokens = {
+    access_token: data.access_token,
+    refresh_token: refreshToken, // Keep existing refresh token
+    expires_at: Date.now() + data.expires_in * 1000,
+    token_type: data.token_type,
+    scope: data.scope,
+  };
+
+  await saveTokens(tokens);
+  return tokens;
+}
+
+/**
+ * Gets valid tokens, refreshing if necessary.
+ * Returns null if no tokens exist or refresh fails.
+ */
+export async function getValidTokens(
+  config: UploadConfig,
+): Promise<Tokens | null> {
+  const tokens = await loadTokens();
+  if (!tokens) return null;
+
+  if (isExpired(tokens) && tokens.refresh_token) {
+    try {
+      return await refreshAccessToken(tokens.refresh_token, config);
+    } catch {
+      return null; // Refresh failed, need to re-login
+    }
+  }
+
+  return tokens;
+}
+
+/**
+ * Performs OAuth login flow - opens browser for user consent.
+ * Stores tokens on success for future use.
+ */
+export async function login(config: UploadConfig): Promise<Tokens> {
+  const authUrl =
+    GOOGLE_AUTH_URL +
+    "?" +
+    new URLSearchParams({
+      client_id: config.clientId,
+      redirect_uri: REDIRECT_URI,
+      response_type: "code",
+      scope: SCOPES.join(" "),
+      access_type: "offline",
+      prompt: "consent",
+    });
+
+  const result = await getAuthCode({
+    authorizationUrl: authUrl,
+    port: 3000,
+    timeout: 300000, // 5 minutes
+  });
+
+  if (!result.code) {
+    throw new Error("No authorization code received");
+  }
+
+  // Exchange code for tokens
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      code: result.code,
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      redirect_uri: REDIRECT_URI,
+      grant_type: "authorization_code",
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  const tokens: Tokens = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Date.now() + data.expires_in * 1000,
+    token_type: data.token_type,
+    scope: data.scope,
+  };
+
+  await saveTokens(tokens);
+  return tokens;
+}
+
+/**
+ * Ensures we have valid tokens - loads existing or triggers login.
+ */
+export async function ensureAuthenticated(
+  config: UploadConfig,
+): Promise<Tokens> {
+  const tokens = await getValidTokens(config);
+  if (tokens) return tokens;
+
+  console.log("Authentication required. Opening browser...");
+  return login(config);
+}
+
+export { OAuthError };

package/src/index.ts

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+
+export { defineConfig, loadConfig, loadConfigFromFile } from "./config.ts";
+export type { Config, BundleConfig } from "./config.ts";