srcpack 0.1.2 → 0.1.3

package/dist/config.d.ts

@@ -7,7 +7,7 @@ declare const BundleConfigSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z
 }, z.core.$strip>]>;
 declare const UploadConfigSchema: z.ZodObject<{
     provider: z.ZodLiteral<"gdrive">;
-    folder: z.ZodOptional<z.ZodString>;
+    folderId: z.ZodOptional<z.ZodString>;
     clientId: z.ZodString;
     clientSecret: z.ZodString;
 }, z.core.$strip>;
@@ -15,12 +15,12 @@ declare const ConfigSchema: z.ZodObject<{
     outDir: z.ZodDefault<z.ZodString>;
     upload: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         provider: z.ZodLiteral<"gdrive">;
-        folder: z.ZodOptional<z.ZodString>;
+        folderId: z.ZodOptional<z.ZodString>;
         clientId: z.ZodString;
         clientSecret: z.ZodString;
     }, z.core.$strip>, z.ZodArray<z.ZodObject<{
         provider: z.ZodLiteral<"gdrive">;
-        folder: z.ZodOptional<z.ZodString>;
+        folderId: z.ZodOptional<z.ZodString>;
         clientId: z.ZodString;
         clientSecret: z.ZodString;
     }, z.core.$strip>>]>>;

package/dist/gdrive.d.ts

@@ -8,14 +8,14 @@ export interface Tokens {
     scope: string;
 }
 /**
- * Loads stored tokens from disk.
+ * Loads stored tokens for a specific OAuth client.
  * Returns null if no tokens exist or they cannot be read.
  */
-export declare function loadTokens(): Promise<Tokens | null>;
+export declare function loadTokens(config: UploadConfig): Promise<Tokens | null>;
 /**
- * Removes stored tokens from disk.
+ * Removes stored tokens for a specific OAuth client.
  */
-export declare function clearTokens(): Promise<void>;
+export declare function clearTokens(config: UploadConfig): Promise<void>;
 /**
  * Gets valid tokens, refreshing if necessary.
  * Returns null if no tokens exist or refresh fails.
@@ -30,4 +30,17 @@ export declare function login(config: UploadConfig): Promise<Tokens>;
  * Ensures we have valid tokens - loads existing or triggers login.
  */
 export declare function ensureAuthenticated(config: UploadConfig): Promise<Tokens>;
+export interface UploadResult {
+    fileId: string;
+    name: string;
+    webViewLink?: string;
+}
+/**
+ * Uploads a file to Google Drive. Updates existing file if found with same name.
+ */
+export declare function uploadFile(filePath: string, config: UploadConfig): Promise<UploadResult>;
+/**
+ * Uploads multiple files to Google Drive.
+ */
+export declare function uploadFiles(filePaths: string[], config: UploadConfig): Promise<UploadResult[]>;
 export { OAuthError };

package/dist/index.js

@@ -113,7 +113,7 @@ var require_parent_module = __commonJS((exports, module) => {
 
 // node_modules/import-fresh/index.js
 var require_import_fresh = __commonJS((exports, module) => {
-  var __dirname = "/Users/koistya/Projects/bundex/node_modules/import-fresh", __filename = "/Users/koistya/Projects/bundex/node_modules/import-fresh/index.js";
+  var __dirname = "/Users/koistya/Projects/srcpack/node_modules/import-fresh", __filename = "/Users/koistya/Projects/srcpack/node_modules/import-fresh/index.js";
   var path = __require("path");
   var resolveFrom = require_resolve_from();
   var parentModule = require_parent_module();
@@ -3721,7 +3721,7 @@ var require_js_yaml = __commonJS((exports, module) => {
 
 // node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS((exports, module) => {
-  var __dirname = "/Users/koistya/Projects/bundex/node_modules/typescript/lib", __filename = "/Users/koistya/Projects/bundex/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/koistya/Projects/srcpack/node_modules/typescript/lib", __filename = "/Users/koistya/Projects/srcpack/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -187017,7 +187017,7 @@ var BundleConfigSchema = exports_external.union([
 ]);
 var UploadConfigSchema = exports_external.object({
   provider: exports_external.literal("gdrive"),
-  folder: exports_external.string().optional(),
+  folderId: exports_external.string().optional(),
   clientId: exports_external.string().min(1),
   clientSecret: exports_external.string().min(1)
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "srcpack",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Zero-config CLI for bundling code into LLM-optimized context files",
   "keywords": [
     "llm",
@@ -54,7 +54,8 @@
     "test": "bun test tests/unit/ tests/e2e/",
     "test:unit": "bun test tests/unit/",
     "test:e2e": "bun test tests/e2e/",
-    "test:login": "bun test --env-file .env.local tests/manual/",
+    "test:login": "bun test --env-file .env.local tests/manual/login.test.ts",
+    "test:upload": "bun test --env-file .env.local tests/manual/upload.test.ts",
     "test:all": "bun test --env-file .env.local tests/",
     "test:watch": "bun test tests/unit/ tests/e2e/ --watch",
     "docs:dev": "vitepress dev",
@@ -64,9 +65,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@googleapis/drive": "^20.0.0",
     "cosmiconfig": "^9.0.0",
+    "google-auth-library": "^10.5.0",
     "ignore": "^7.0.5",
     "oauth-callback": "^1.2.5",
+    "ora": "^9.0.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {

package/src/cli.ts

@@ -3,9 +3,21 @@
 
 import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import ora from "ora";
 import { bundleOne, type BundleResult } from "./bundle.ts";
-import { loadConfig, type BundleConfig, type UploadConfig } from "./config.ts";
-import { ensureAuthenticated, login, OAuthError } from "./gdrive.ts";
+import {
+  ConfigError,
+  loadConfig,
+  type BundleConfig,
+  type UploadConfig,
+} from "./config.ts";
+import {
+  ensureAuthenticated,
+  login,
+  OAuthError,
+  uploadFile,
+  type UploadResult,
+} from "./gdrive.ts";
 import { runInit } from "./init.ts";
 
 interface BundleOutput {
@@ -36,13 +48,15 @@ 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 --dry-run    Preview bundles without writing files
+  npx srcpack --no-upload  Bundle only, skip upload
   npx srcpack init         Interactive config setup
   npx srcpack login        Authenticate with Google Drive
 
 Options:
-  --dry-run    Preview bundles without uploading
-  -h, --help   Show this help message
+  --dry-run     Preview bundles without writing files
+  --no-upload   Skip uploading to cloud storage
+  -h, --help    Show this help message
 `);
     return;
   }
@@ -58,6 +72,7 @@ Options:
   }
 
   const dryRun = args.includes("--dry-run");
+  const noUpload = args.includes("--no-upload");
   const subcommands = ["init", "login"];
   const requestedBundles = args.filter(
     (arg) => !arg.startsWith("-") && !subcommands.includes(arg),
@@ -93,14 +108,23 @@ Options:
   const cwd = process.cwd();
   const outputs: BundleOutput[] = [];
 
-  // Process all bundles
-  for (const name of bundleNames) {
+  // Process all bundles with progress
+  const bundleSpinner = ora({
+    text: `Bundling ${bundleNames[0]}...`,
+    color: "cyan",
+  }).start();
+
+  for (let i = 0; i < bundleNames.length; i++) {
+    const name = bundleNames[i]!;
+    bundleSpinner.text = `Bundling ${name}... (${i + 1}/${bundleNames.length})`;
     const bundleConfig = config.bundles[name]!;
     const result = await bundleOne(name, bundleConfig, cwd);
     const outfile = getOutfile(bundleConfig, name, config.outDir);
     outputs.push({ name, outfile, result });
   }
 
+  bundleSpinner.stop();
+
   // Calculate column widths for aligned output
   const maxNameLen = Math.max(...outputs.map((o) => o.name.length));
   const maxFilesLen = Math.max(
@@ -151,18 +175,18 @@ Options:
     );
   } else {
     console.log(
-      `Done: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
+      `Bundled: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
     );
 
-    // Handle upload if configured
-    if (config.upload) {
+    // Handle upload if configured and not disabled
+    if (config.upload && !noUpload) {
       const uploads = Array.isArray(config.upload)
         ? config.upload
         : [config.upload];
 
       for (const uploadConfig of uploads) {
         if (isGdriveConfigured(uploadConfig)) {
-          await handleGdriveUpload(uploadConfig, outputs);
+          await handleGdriveUpload(uploadConfig, outputs, cwd);
         }
       }
     }
@@ -188,7 +212,16 @@ function getGdriveConfig(config: {
 }
 
 async function runLogin(): Promise<void> {
-  const config = await loadConfig();
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (error) {
+    if (error instanceof ConfigError && error.message.includes("upload")) {
+      printUploadConfigHelp();
+      process.exit(1);
+    }
+    throw error;
+  }
 
   if (!config) {
     console.error(
@@ -197,19 +230,25 @@ async function runLogin(): Promise<void> {
     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",
-    );
+  if (!config.upload) {
+    printUploadConfigHelp();
+    process.exit(1);
+  }
+
+  const uploads = Array.isArray(config.upload)
+    ? config.upload
+    : [config.upload];
+  const gdriveConfig = uploads.find((u) => u.provider === "gdrive");
+
+  if (!gdriveConfig) {
+    console.error('No upload config with provider: "gdrive" found.');
     process.exit(1);
   }
 
   try {
     console.log("Opening browser for authentication...");
-    await login(uploadConfig);
-    console.log("Login successful. Tokens saved to ~/.srcpack/tokens.json");
+    await login(gdriveConfig);
+    console.log("Login successful.");
   } catch (error) {
     if (error instanceof OAuthError) {
       console.error(`OAuth error: ${error.error}`);
@@ -222,22 +261,59 @@ async function runLogin(): Promise<void> {
   }
 }
 
+function printUploadConfigHelp(): void {
+  console.error("Upload configuration incomplete or missing.");
+  console.error("Add to srcpack.config.ts:");
+  console.error(`
+  upload: {
+    provider: "gdrive",
+    folderId: "...",      // optional - Google Drive folder ID
+    clientId: "...",      // required - OAuth 2.0 client ID
+    clientSecret: "...",  // required - OAuth 2.0 client secret
+  }
+`);
+}
+
 async function handleGdriveUpload(
   uploadConfig: UploadConfig,
-  _outputs: BundleOutput[],
+  outputs: BundleOutput[],
+  cwd: string,
 ): Promise<void> {
   try {
     await ensureAuthenticated(uploadConfig);
 
-    // TODO: Upload bundles to Google Drive using tokens
+    const uploadSpinner = ora({
+      text: `Uploading to Google Drive...`,
+      color: "cyan",
+    }).start();
+
+    const results: UploadResult[] = [];
+
+    for (let i = 0; i < outputs.length; i++) {
+      const output = outputs[i]!;
+      const filePath = join(cwd, output.outfile);
+      uploadSpinner.text = `Uploading ${output.name}... (${i + 1}/${outputs.length})`;
+      const result = await uploadFile(filePath, uploadConfig);
+      results.push(result);
+    }
+
+    uploadSpinner.stop();
+
+    // Print upload summary
     console.log();
-    console.log("Authenticated with Google Drive.");
-    if (uploadConfig.folder) {
-      console.log(`Ready to upload to folder: ${uploadConfig.folder}`);
+    const uploadWord = plural(results.length, "file");
+    console.log(`Uploaded: ${results.length} ${uploadWord} to Google Drive`);
+
+    for (const result of results) {
+      if (result.webViewLink) {
+        console.log(`  ${result.name} → ${result.webViewLink}`);
+      } else {
+        console.log(`  ${result.name}`);
+      }
     }
   } catch (error) {
     if (error instanceof OAuthError) {
-      console.error(`OAuth error: ${error.error}`);
+      console.error(`\nOAuth error: ${error.error}`);
       if (error.error_description) {
         console.error(`  ${error.error_description}`);
       }

package/src/config.ts

@@ -29,7 +29,7 @@ const BundleConfigSchema = z.union([
 
 const UploadConfigSchema = z.object({
   provider: z.literal("gdrive"),
-  folder: z.string().optional(),
+  folderId: z.string().optional(),
   clientId: z.string().min(1),
   clientSecret: z.string().min(1),
 });

package/src/gdrive.ts

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: MIT
 
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, basename } from "node:path";
+import { drive as createDrive, type drive_v3 } from "@googleapis/drive";
+import { OAuth2Client } from "google-auth-library";
 import { getAuthCode, OAuthError } from "oauth-callback";
 import type { UploadConfig } from "./config.ts";
 
@@ -10,7 +13,7 @@ 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");
+const CREDENTIALS_PATH = join(homedir(), ".config", "srcpack", "credentials.json");
 
 export interface Tokens {
   access_token: string;
@@ -28,35 +31,52 @@ interface TokenResponse {
   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> {
+// Credentials keyed by provider, then by clientId for multi-destination support
+interface CredentialsFile {
+  gdrive?: Record<string, Tokens>;
+}
+
+async function readCredentials(): Promise<CredentialsFile> {
   try {
-    const data = await readFile(TOKENS_PATH, "utf-8");
-    return JSON.parse(data) as Tokens;
+    const data = await readFile(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(data) as CredentialsFile;
   } catch {
-    return null;
+    return {};
   }
 }
 
+async function writeCredentials(creds: CredentialsFile): Promise<void> {
+  await mkdir(dirname(CREDENTIALS_PATH), { recursive: true });
+  await writeFile(CREDENTIALS_PATH, JSON.stringify(creds, null, 2));
+}
+
 /**
- * Saves tokens to disk for later use.
+ * Loads stored tokens for a specific OAuth client.
+ * Returns null if no tokens exist or they cannot be read.
  */
-async function saveTokens(tokens: Tokens): Promise<void> {
-  await mkdir(dirname(TOKENS_PATH), { recursive: true });
-  await writeFile(TOKENS_PATH, JSON.stringify(tokens, null, 2));
+export async function loadTokens(config: UploadConfig): Promise<Tokens | null> {
+  const creds = await readCredentials();
+  return creds.gdrive?.[config.clientId] ?? null;
 }
 
 /**
- * Removes stored tokens from disk.
+ * Saves tokens for a specific OAuth client.
  */
-export async function clearTokens(): Promise<void> {
-  try {
-    await unlink(TOKENS_PATH);
-  } catch {
-    // Ignore if file doesn't exist
+async function saveTokens(tokens: Tokens, config: UploadConfig): Promise<void> {
+  const creds = await readCredentials();
+  creds.gdrive ??= {};
+  creds.gdrive[config.clientId] = tokens;
+  await writeCredentials(creds);
+}
+
+/**
+ * Removes stored tokens for a specific OAuth client.
+ */
+export async function clearTokens(config: UploadConfig): Promise<void> {
+  const creds = await readCredentials();
+  if (creds.gdrive?.[config.clientId]) {
+    delete creds.gdrive[config.clientId];
+    await writeCredentials(creds);
   }
 }
 
@@ -101,7 +121,7 @@ async function refreshAccessToken(
     scope: data.scope,
   };
 
-  await saveTokens(tokens);
+  await saveTokens(tokens, config);
   return tokens;
 }
 
@@ -112,7 +132,7 @@ async function refreshAccessToken(
 export async function getValidTokens(
   config: UploadConfig,
 ): Promise<Tokens | null> {
-  const tokens = await loadTokens();
+  const tokens = await loadTokens(config);
   if (!tokens) return null;
 
   if (isExpired(tokens) && tokens.refresh_token) {
@@ -180,7 +200,7 @@ export async function login(config: UploadConfig): Promise<Tokens> {
     scope: data.scope,
   };
 
-  await saveTokens(tokens);
+  await saveTokens(tokens, config);
   return tokens;
 }
 
@@ -197,4 +217,121 @@ export async function ensureAuthenticated(
   return login(config);
 }
 
+/**
+ * Creates an authenticated OAuth2 client from tokens.
+ */
+function createAuthClient(tokens: Tokens, config: UploadConfig): OAuth2Client {
+  const client = new OAuth2Client(config.clientId, config.clientSecret);
+  client.setCredentials({
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+  });
+  return client;
+}
+
+/**
+ * Creates an authenticated Google Drive client.
+ */
+function createDriveClient(
+  tokens: Tokens,
+  config: UploadConfig,
+): drive_v3.Drive {
+  const auth = createAuthClient(tokens, config);
+  return createDrive({ version: "v3", auth });
+}
+
+/**
+ * Finds a file by name in a specific folder (or root).
+ * Returns the file ID if found, null otherwise.
+ */
+async function findFile(
+  drive: drive_v3.Drive,
+  name: string,
+  folderId?: string,
+): Promise<string | null> {
+  const parent = folderId ?? "root";
+  const query = `name = '${name}' and '${parent}' in parents and trashed = false`;
+
+  const res = await drive.files.list({
+    q: query,
+    fields: "files(id, name)",
+    spaces: "drive",
+  });
+
+  return res.data.files?.[0]?.id ?? null;
+}
+
+export interface UploadResult {
+  fileId: string;
+  name: string;
+  webViewLink?: string;
+}
+
+/**
+ * Uploads a file to Google Drive. Updates existing file if found with same name.
+ */
+export async function uploadFile(
+  filePath: string,
+  config: UploadConfig,
+): Promise<UploadResult> {
+  const tokens = await ensureAuthenticated(config);
+  const drive = createDriveClient(tokens, config);
+  const fileName = basename(filePath);
+
+  // Check if file already exists in target folder
+  const existingId = await findFile(drive, fileName, config.folderId);
+
+  const media = {
+    mimeType: "text/plain",
+    body: createReadStream(filePath),
+  };
+
+  let res: { data: drive_v3.Schema$File };
+
+  if (existingId) {
+    // Update existing file
+    res = await drive.files.update({
+      fileId: existingId,
+      media,
+      fields: "id, name, webViewLink",
+    });
+  } else {
+    // Create new file
+    const requestBody: drive_v3.Schema$File = {
+      name: fileName,
+    };
+
+    if (config.folderId) {
+      requestBody.parents = [config.folderId];
+    }
+
+    res = await drive.files.create({
+      requestBody,
+      media,
+      fields: "id, name, webViewLink",
+    });
+  }
+
+  return {
+    fileId: res.data.id!,
+    name: res.data.name!,
+    webViewLink: res.data.webViewLink ?? undefined,
+  };
+}
+
+/**
+ * Uploads multiple files to Google Drive.
+ */
+export async function uploadFiles(
+  filePaths: string[],
+  config: UploadConfig,
+): Promise<UploadResult[]> {
+  const results: UploadResult[] = [];
+  for (const filePath of filePaths) {
+    const result = await uploadFile(filePath, config);
+    results.push(result);
+  }
+  return results;
+}
+
 export { OAuthError };