gasup 0.4.4 → 1.0.0

package/README.md

@@ -1,123 +1,196 @@
 # Gasup
 
-Gasup is a command-line interface (CLI) tool designed to simplify the process.
+A simple CLI tool for bundling Google Apps Script projects with esbuild and the esbuild-gas-plugin.
 
-- building
-- bundling
-- pushing
-- deploying
-- change development, staging, production
+## Features
 
-It offers an easy way to automate tasks and manage your deployments without the need to manually interact with the Apps Script dashboard.
+- **Simple bundling**: Bundle your TypeScript/JavaScript code into a single file optimized for Google Apps Script
+- **Easy configuration**: Interactive wizard to create configuration files
+- **esbuild-gas-plugin integration**: Automatically handles GAS-specific optimizations
+- **File management**: Automatically copies `appsscript.json` and HTML files to the output directory
 
 ## Installation
 
-To get started with gasup, you need clasp first.
+Install gasup as a dev dependency:
 
-Then you can install gasup like below.
-
-```
-npm i -D gasup
+```bash
+npm install -D gasup
 ```
 
-## Usage
+## Quick Start
 
-### Build
+1. **Initialize your project** (creates `gasup.config.ts`):
+   ```bash
+   npx gasup init
+   ```
 
-Simple build.
+2. **Bundle your project**:
+   ```bash
+   npx gasup
+   ```
 
-```
-gasup --build
-```
+3. **Push to Google Apps Script**:
+   ```bash
+   clasp push
+   ```
 
-This command compiles your code with tsc.
+## Commands
 
-### Bundle
+### `gasup`
+Bundles your Google Apps Script project using the current configuration.
 
-Bundle with esbuild into one file.
+```bash
+# Using npx
+npx gasup
 
-```
-gasup --bundle
+# Using pnpm
+pnpm gasup
+
+# Using yarn
+yarn gasup
 ```
 
- This allows you to use libraries that are not natively available in Google Apps Script.
+### `gasup init`
+Interactive wizard to create a `gasup.config.ts` configuration file.
 
-### Push
+```bash
+# Using npx
+npx gasup init
 
-Simply push using "clasp push".
+# Using pnpm
+pnpm gasup init
 
-```
-gasup --push
+# Using yarn
+yarn gasup init
 ```
 
-### Deploy
+The wizard will ask for:
+- Entry point (default: `src/index.ts`)
+- Output file (default: `dist/bundle.js`)
+- appsscript.json path (default: `appsscript.json`)
 
-Deploy to the latest deployment. If no previous deployments exist, a new deployment will be created.
+### `gasup config`
+Displays the current configuration.
 
-```
-gasup --deploy
+```bash
+# Using npx
+npx gasup config
+
+# Using pnpm
+pnpm gasup config
+
+# Using yarn
+yarn gasup config
 ```
 
-appsscript.json affects deployment. Be sure to check your appsscript.json.
+## Using npm scripts (Recommended)
 
-If you want to deploy webapp, appsscript is like below.
+Add these scripts to your `package.json` for easier access:
 
 ```json
 {
-  "webapp": {
-    "executeAs": "USER_DEPLOYING",
-    "access": "ANYONE_ANONYMOUS"
+  "scripts": {
+    "build": "gasup",
+    "init": "gasup init",
+    "config": "gasup config"
   }
 }
 ```
 
-### Change Environment
+Then you can run:
 
-If you need to switch between different environments (e.g., development, staging, production), you can use the --env flag to modify the appsscript.json file accordingly.
-
-```
-gasup --env <envpath>
+```bash
+npm run init    # Initialize configuration
+npm run build   # Bundle your project
+npm run config  # Show configuration
 ```
 
-Environment file details:
+## Configuration
+
+Create a `gasup.config.ts` file in your project root:
+
+```typescript
+import { Config } from 'gasup';
 
-```env
-GASUP_SCRIPT_ID=xxx
-GASUP_PARENT_ID=yyy,zzz
+const config: Config = {
+  entryPoint: 'src/index.ts',
+  outputFile: 'dist/bundle.js',
+  appsScriptJsonPath: 'appsscript.json',
+};
+
+export default config;
 ```
 
-### Chain
+### Configuration Options
 
-Chan command is available like below.
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `entryPoint` | `string` | `'src/index.ts'` | Path to your main TypeScript/JavaScript file |
+| `outputFile` | `string` | `'dist/bundle.js'` | Path for the bundled output file |
+| `appsScriptJsonPath` | `string` | `'appsscript.json'` | Path to your appsscript.json file |
+
+## Project Structure
 
 ```
-gasup --env .env.production --bundle --push --deploy
+your-project/
+├── src/
+│   └── index.ts          # Your main entry point
+├── dist/
+│   ├── bundle.js         # Bundled output (auto-generated)
+│   └── appsscript.json   # Copied from root (auto-generated)
+├── appsscript.json       # Google Apps Script configuration
+├── gasup.config.ts       # Gasup configuration (optional)
+└── package.json
 ```
 
-### Config
+## How it works
+
+1. **Bundling**: Uses esbuild with the esbuild-gas-plugin to bundle your code
+2. **Optimization**: Automatically applies Google Apps Script-specific optimizations
+3. **File copying**: Copies `appsscript.json` and any HTML files to the output directory
+4. **Ready for deployment**: The bundled file is ready to be pushed to Google Apps Script
+
+## Examples
+
+### Basic usage
+```bash
+# Initialize configuration
+npx gasup init
+
+# Bundle your project
+npx gasup
 
-The config file will below.
+# Push to Google Apps Script
+clasp push
+```
+
+### Using npm scripts
+```bash
+# Add to package.json scripts
+npm run init
+npm run build
+clasp push
+```
 
-```ts
+### Custom configuration
+```typescript
 // gasup.config.ts
 import { Config } from 'gasup';
 
-const config:Config = {
-  srcDir: './src';
-}
+const config: Config = {
+  entryPoint: 'src/main.ts',
+  outputFile: 'build/script.js',
+  appsScriptJsonPath: 'gas/appsscript.json',
+};
 
 export default config;
 ```
 
-```ts
-export interface Config {
-  appsScriptJsonPath?: string;
-  bundleEntries?: string[];
-  bundleOutfile?: string;
-  srcDir?: string;
-  distDir?: string;
-}
-```
+## Requirements
+
+- Node.js 18+
+- Google Apps Script project set up with clasp
+- TypeScript or JavaScript source files
 
 ## License
 

package/dist/bin/gasup.js

@@ -1,51 +1,52 @@
-import { execSync } from 'child_process';
 import { program } from 'commander';
-import { build } from '../build.js';
 import { bundle } from '../bundle.js';
 import { loadConfigWithDefault } from '../config.js';
-import { deploy } from '../deploy.js';
-import { changeEnv } from '../envFile/changeEnv.js';
+import { init } from '../init.js';
 program
-    .option('--config', 'display current configuration')
-    .option('--env <envpath>', 'apply env to clasp')
-    .option('--bundle', 'bundle')
-    .option('--build', 'build')
-    .option('--push', 'push')
-    .option('--deploy', 'deploy')
-    .parse();
-async function main() {
-    const opts = program.opts();
-    const config = await loadConfigWithDefault();
-    if (opts.config) {
-        console.log({ config });
-        return;
-    }
-    if (opts.env?.startsWith('--')) {
-        throw new Error('env option is required');
+    .name('gasup')
+    .description('CLI tool for Google Apps Script bundling')
+    .version('0.4.4');
+// Main command (bundle execution)
+program
+    .description('Bundle your Google Apps Script project')
+    .action(async () => {
+    try {
+        const config = await loadConfigWithDefault();
+        console.log('📦 Bundling with esbuild...');
+        await bundle(config);
+        console.log('✅ Bundle completed');
     }
-    if (opts.env) {
-        console.log(`apply ${opts.env} to clasp`);
-        changeEnv(opts.env, config);
+    catch (error) {
+        console.error('❌ Bundle failed:', error);
+        process.exit(1);
     }
-    if (opts.build) {
-        console.log('build with tsc');
-        build(config);
+});
+// init subcommand
+program
+    .command('init')
+    .description('Initialize gasup configuration file')
+    .action(async () => {
+    try {
+        await init();
     }
-    if (opts.bundle) {
-        console.log('bundle with esbuild');
-        await bundle(config);
+    catch (error) {
+        console.error('❌ Init failed:', error);
+        process.exit(1);
     }
-    if (opts.push) {
-        console.log('push');
-        execSync('clasp push', { stdio: 'inherit' });
+});
+// config subcommand
+program
+    .command('config')
+    .description('Display current configuration')
+    .action(async () => {
+    try {
+        const config = await loadConfigWithDefault();
+        console.log('📋 Current configuration:');
+        console.log(JSON.stringify(config, null, 2));
     }
-    if (opts.deploy) {
-        console.log(`deploy`);
-        deploy();
+    catch (error) {
+        console.error('❌ Config display failed:', error);
+        process.exit(1);
     }
-    console.log('gasup done');
-}
-main().catch((err) => {
-    console.error(err.message);
-    process.exit(1);
 });
+program.parse();

package/dist/bundle.js

@@ -1,17 +1,19 @@
 import esbuild from 'esbuild';
 import { GasPlugin } from 'esbuild-gas-plugin';
-import fs from 'fs-extra';
+import fs from 'fs';
 import path from 'path';
 export async function bundle(config) {
-    const { bundleEntries, bundleOutfile, appsScriptJsonPath, distDir } = config;
+    const { appsScriptJsonPath, entryPoint, outputFile } = config;
+    const bundleEntries = [entryPoint];
     await esbuild.build({
         entryPoints: bundleEntries,
         bundle: true,
-        outfile: bundleOutfile,
+        outfile: outputFile,
         plugins: [GasPlugin],
     });
+    const distDir = path.dirname(outputFile);
     fs.copyFileSync(appsScriptJsonPath, path.join(distDir, 'appsscript.json'));
-    // HTMLファイルをdistディレクトリにコピー
+    // Copy HTML files to dist directory
     for (const bundleEntry of bundleEntries) {
         const entryDir = path.dirname(bundleEntry);
         const htmlFiles = fs.readdirSync(entryDir).filter(file => file.endsWith('.html'));

package/dist/config.d.ts

@@ -1,10 +1,7 @@
 import { Config } from './types.js';
 export declare const defaultConfig: Config;
 export declare function loadConfigWithDefault(): Promise<{
-    claspJsonPath?: string;
+    entryPoint?: string;
+    outputFile?: string;
     appsScriptJsonPath?: string;
-    bundleEntries?: string[];
-    bundleOutfile?: string;
-    srcDir?: string;
-    distDir?: string;
 }>;

package/dist/config.js

@@ -1,16 +1,12 @@
-import fs from 'fs-extra';
+import fs from 'fs';
 import path from 'path';
 import tsnode from 'ts-node';
 const configFileName = 'gasup.config.ts';
 export const defaultConfig = {
-    claspJsonPath: '.clasp.json',
+    entryPoint: 'src/index.ts',
+    outputFile: 'dist/bundle.js',
     appsScriptJsonPath: 'appsscript.json',
-    bundleEntries: [path.join('src', 'index.ts')],
-    bundleOutfile: path.join('dist', 'bundle.js'),
-    srcDir: 'src',
-    distDir: 'dist',
 };
-// export const config = loadConfigWithDefault();
 export async function loadConfigWithDefault() {
     const configPath = path.join(process.cwd(), configFileName);
     const config = await loadConfig(configPath);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export * from './bundle.js';
-export * from './envFile/changeEnv.js';
 export * from './config.js';
 export * from './types.js';
+export * from './init.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export * from './bundle.js';
-export * from './envFile/changeEnv.js';
 export * from './config.js';
 export * from './types.js';
+export * from './init.js';

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/init.js

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+const defaultConfig = {
+    entryPoint: 'src/index.ts',
+    outputFile: 'dist/bundle.js',
+    appsScriptJsonPath: 'appsscript.json',
+};
+export async function init() {
+    console.log('🚀 Gasup Configuration Wizard');
+    console.log('');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (query) => {
+        return new Promise((resolve) => {
+            rl.question(query, resolve);
+        });
+    };
+    try {
+        // Entry point
+        const entryPoint = await question(`Entry point (default: ${defaultConfig.entryPoint}): `);
+        // Output file
+        const outputFile = await question(`Output file (default: ${defaultConfig.outputFile}): `);
+        // appsscript.json path
+        const appsScriptJsonPath = await question(`appsscript.json path (default: ${defaultConfig.appsScriptJsonPath}): `);
+        rl.close();
+        // Create config object
+        const config = {
+            entryPoint: entryPoint || defaultConfig.entryPoint,
+            outputFile: outputFile || defaultConfig.outputFile,
+            appsScriptJsonPath: appsScriptJsonPath || defaultConfig.appsScriptJsonPath,
+        };
+        // Generate config file content
+        const configContent = generateConfigFile(config);
+        // Write to file
+        const configPath = path.join(process.cwd(), 'gasup.config.ts');
+        fs.writeFileSync(configPath, configContent);
+        console.log('');
+        console.log('✅ Configuration file created: gasup.config.ts');
+        console.log('');
+        console.log('Configuration:');
+        console.log(JSON.stringify(config, null, 2));
+        console.log('');
+        console.log('You can now run `gasup` to bundle your project.');
+    }
+    catch (error) {
+        rl.close();
+        console.error('❌ Failed to create configuration file:', error);
+        process.exit(1);
+    }
+}
+function generateConfigFile(config) {
+    return `import { Config } from 'gasup';
+
+const config: Config = {
+  entryPoint: '${config.entryPoint}',
+  outputFile: '${config.outputFile}',
+  appsScriptJsonPath: '${config.appsScriptJsonPath}',
+};
+
+export default config;
+`;
+}

package/dist/types.d.ts

@@ -1,18 +1,5 @@
-export type Env = 'dev' | 'stag' | 'prod';
 export interface Config {
-    claspJsonPath?: string;
+    entryPoint?: string;
+    outputFile?: string;
     appsScriptJsonPath?: string;
-    bundleEntries?: string[];
-    bundleOutfile?: string;
-    srcDir?: string;
-    distDir?: string;
-}
-export interface EnvObject {
-    GASUP_SCRIPT_ID?: string;
-    GASUP_PARENT_ID?: string[];
-}
-export interface ClaspJson {
-    scriptId?: string;
-    rootDir?: string;
-    parentId?: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gasup",
-  "version": "0.4.4",
+  "version": "1.0.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -12,8 +12,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "assets"
+    "dist"
   ],
   "keywords": [
     "gas",
@@ -22,18 +21,14 @@
     "google apps script"
   ],
   "dependencies": {
-    "commander": "^13.0.0",
-    "dotenv": "^16.4.7",
-    "esbuild": ">=0.25.0",
-    "esbuild-gas-plugin": "^0.8.0",
-    "fs-extra": "^11.3.0",
-    "remeda": "^2.19.2",
-    "ts-node": "^10.9.2"
+    "commander": "^13.1.0",
+    "esbuild": "^0.25.5",
+    "esbuild-gas-plugin": "^0.9.0"
   },
   "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.10.7",
-    "vitest": "^3.0.5"
+    "@types/node": "^22.15.30",
+    "ts-node": "^10.9.2",
+    "vitest": "^3.2.2"
   },
   "scripts": {
     "build": "tsc",

package/assets/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "lib": [
-      "ES2020"
-    ],
-  }
-}

package/dist/build.d.ts

@@ -1,2 +0,0 @@
-import { Config } from './types.js';
-export declare function build(config: Config): void;

package/dist/build.js

@@ -1,7 +0,0 @@
-import { execSync } from 'child_process';
-import { copyFileSync } from 'fs';
-import path from 'path';
-export function build(config) {
-    execSync('tsc', { stdio: 'inherit' });
-    copyFileSync(config.appsScriptJsonPath, path.join(config.distDir, 'appsscript.json'));
-}

package/dist/claspJson.d.ts

@@ -1,2 +0,0 @@
-import { ClaspJson } from './types.js';
-export declare function updateClaspJson(claspJsonPath: string, data: ClaspJson): void;

package/dist/claspJson.js

@@ -1,7 +0,0 @@
-import fs from 'fs-extra';
-export function updateClaspJson(claspJsonPath, data) {
-    const json = fs.readFileSync(claspJsonPath, 'utf-8');
-    const existingData = JSON.parse(json ?? '{}');
-    const newData = { ...existingData, ...data };
-    fs.writeFileSync(claspJsonPath, JSON.stringify(newData, null, 2));
-}

package/dist/deploy.d.ts

@@ -1 +0,0 @@
-export declare function deploy(): void;

package/dist/deploy.js

@@ -1,27 +0,0 @@
-import { execSync } from 'child_process';
-export function deploy() {
-    const currentDeployments = getCurrentDeployments();
-    const latestDeployment = currentDeployments[0];
-    if (latestDeployment) {
-        console.log('deploy to latest: ' +
-            latestDeployment.id +
-            ' ' +
-            latestDeployment.version);
-        execSync('clasp deploy -i ' + latestDeployment.id);
-    }
-    else {
-        console.log('deploy new version');
-        execSync('clasp deploy');
-    }
-}
-function getCurrentDeployments() {
-    const res = execSync('clasp deployments').toString();
-    const lines = res.split('\n');
-    const deployments = lines
-        .filter((line) => line.startsWith('-'))
-        .map((line) => {
-        const [_, id, versionStr] = line.split(' ');
-        return { id, version: Number(versionStr.replace(/[^\d]/g, '')) };
-    });
-    return deployments.sort((a, b) => b.version - a.version);
-}

package/dist/envFile/addToEnvString.d.ts

@@ -1 +0,0 @@
-export declare function addToEnvString(envString: string, _items: Record<string, string>): string;

package/dist/envFile/addToEnvString.js

@@ -1,39 +0,0 @@
-// 環境変数を変更する
-export function addToEnvString(envString, _items) {
-    const items = { ..._items };
-    const newLines = [];
-    for (const line of envString.split('\n')) {
-        if (isCommentLine(line)) {
-            newLines.push(line);
-        }
-        else {
-            const { key, value } = parseLine(line);
-            if (key) {
-                if (items[key]) {
-                    newLines.push(`${key}=${items[key]}`);
-                    delete items[key];
-                }
-                else {
-                    newLines.push(`${key}=${value}`);
-                }
-            }
-            else {
-                newLines.push('');
-            }
-        }
-    }
-    newLines.push('');
-    for (const [key, value] of Object.entries(items)) {
-        if (!key)
-            continue;
-        newLines.push(`${key}=${value}`);
-    }
-    return newLines.join('\n');
-}
-function isCommentLine(line) {
-    return line.startsWith('#');
-}
-function parseLine(line) {
-    const [key, ...values] = line.split('=');
-    return { key, value: values.join('=') };
-}

package/dist/envFile/addToEnvString.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/envFile/addToEnvString.test.js

@@ -1,56 +0,0 @@
-import { addToEnvString } from './addToEnvString.js';
-import { describe, it, expect } from 'vitest';
-describe('addToEnvString', () => {
-    const mockEnvString = `
-# This is a comment
-KEY1=value1
-KEY2=value2
-`.trim();
-    it('should add new keys to the env string and overwrite existing ones', () => {
-        const itemsToAdd = {
-            KEY3: 'value3',
-            KEY1: 'newValue1', // 既存のKEY1を上書きしない
-        };
-        const result = addToEnvString(mockEnvString, itemsToAdd);
-        // 新しい環境変数を含んだ結果を確認
-        const expectedContent = `
-# This is a comment
-KEY1=value1
-KEY2=value2
-
-KEY3=value3
-`.trim();
-        console.log({ mockEnvString, result, expectedContent });
-        expect(result).toBe(expectedContent);
-    });
-    it('should add only new keys if not already in the string', () => {
-        const itemsToAdd = {
-            KEY3: 'value3',
-            KEY4: 'value4',
-        };
-        const result = addToEnvString(mockEnvString, itemsToAdd);
-        // 新しい環境変数を含んだ結果を確認
-        const expectedContent = `
-# This is a comment
-KEY1=value1
-KEY2=value2
-
-KEY3=value3
-KEY4=value4
-`.trim();
-        expect(result).toBe(expectedContent);
-    });
-    it('should handle an empty env string', () => {
-        const itemsToAdd = {
-            KEY1: 'value1',
-            KEY2: 'value2',
-        };
-        const result = addToEnvString('', itemsToAdd);
-        // 空の環境変数文字列に対して追加された内容を確認
-        const expectedContent = `
-KEY1=value1
-KEY2=value2
-`.trim();
-        expect(result.trim()).toBe(expectedContent);
-    });
-});

package/dist/envFile/changeEnv.d.ts

@@ -1,2 +0,0 @@
-import { Config } from '../types.js';
-export declare function changeEnv(envPath: string, config: Config): void;

package/dist/envFile/changeEnv.js

@@ -1,24 +0,0 @@
-import fs from 'fs-extra';
-import { updateClaspJson } from '../claspJson.js';
-import { getEnvData } from './envFile.js';
-export function changeEnv(envPath, config) {
-    if (!envPath) {
-        throw new Error(`envPath not found on ${envPath}`);
-    }
-    if (!fs.existsSync(envPath)) {
-        throw new Error(`${envPath} not found`);
-    }
-    const envData = getEnvData(envPath);
-    const scriptId = envData.GASUP_SCRIPT_ID;
-    const parentIds = envData.GASUP_PARENT_ID;
-    if (!scriptId) {
-        throw new Error(`GASUP_SCRIPT_ID not found on ${envPath}`);
-    }
-    if (!parentIds) {
-        throw new Error(`GASUP_PARENT_ID not found on ${envPath}`);
-    }
-    updateClaspJson(config.claspJsonPath, {
-        scriptId,
-        parentId: parentIds,
-    });
-}

package/dist/envFile/envFile.d.ts

@@ -1,3 +0,0 @@
-import { EnvObject } from '../types.js';
-export declare function getEnvData(envPath: string): EnvObject;
-export declare function addToEnvFile(envPath: string, _items: Record<string, string>): void;

package/dist/envFile/envFile.js

@@ -1,25 +0,0 @@
-import dotenv from 'dotenv';
-import fs from 'fs-extra';
-import { addToEnvString } from './addToEnvString.js';
-export function getEnvData(envPath) {
-    try {
-        const envString = fs.readFileSync(envPath, 'utf-8');
-        const data = dotenv.parse(envString);
-        return {
-            GASUP_SCRIPT_ID: data.GASUP_SCRIPT_ID,
-            GASUP_PARENT_ID: data.GASUP_PARENT_ID?.split(','),
-        };
-    }
-    catch (err) {
-        return {};
-    }
-}
-export function addToEnvFile(envPath, _items) {
-    let envString = '';
-    try {
-        envString = fs.readFileSync(envPath, 'utf-8');
-    }
-    catch (e) { }
-    const newEnvString = addToEnvString(envString.trim(), _items);
-    fs.writeFileSync(envPath, newEnvString);
-}

package/dist/gitignore.d.ts

@@ -1 +0,0 @@
-export declare function addGitIgnores(): void;

package/dist/gitignore.js

@@ -1,18 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import * as R from 'remeda';
-export function addGitIgnores() {
-    const filePath = path.join(process.cwd(), '.gitignore');
-    const existsIgnores = read(filePath);
-    const ignores = ['node_modules', '.DS_Store', '.env*', '.clasp.json'];
-    const newIgnores = R.unique([...existsIgnores, ...ignores]);
-    fs.writeFileSync(filePath, newIgnores.join('\n'));
-}
-function read(filePath) {
-    try {
-        return fs.readFileSync(filePath).toString().split('\n');
-    }
-    catch (err) {
-        return [];
-    }
-}