deckide 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 tako0614
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# Deck IDE
+
+複数のターミナルを並列で管理できる軽量なWeb IDE。AIエージェント（Claude Code、Codex CLI等）を永続的に動かすことに最適化されています。
+
+## 特徴
+
+- **マルチターミナル** - 複数のターミナルを同時に起動・管理
+- **Monaco Editor** - VS Codeと同じエディタエンジンによるコード編集
+- **Git統合** - ステージング、コミット、プッシュ、プル、ブランチ管理
+- **マルチリポジトリ対応** - ワークスペース内の複数Gitリポジトリを自動検出
+- **ファイルエクスプローラー** - ファイル・フォルダの作成、削除、名前変更
+- **Diffビューア** - 変更ファイルの差分表示
+- **Windowsデスクトップアプリ** - Electronベースのネイティブアプリ（自動アップデート対応）
+
+## スクリーンショット
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ [エクスプローラー] [Git] [設定]    Deck IDE                  │
+├─────────┬───────────────────────────────────────────────────┤
+│ ファイル │  Monaco Editor                                    │
+│ ツリー   │                                                   │
+│         │                                                    │
+│         ├───────────────────────────────────────────────────┤
+│         │  Terminal 1        │  Terminal 2                  │
+│         │  $ claude          │  $ codex                     │
+│         │  ...               │  ...                         │
+└─────────┴───────────────────────────────────────────────────┘
+```
+
+## インストール
+
+### Windowsデスクトップアプリ（推奨）
+
+[Releases](https://github.com/tako0614/ide/releases)から最新の`Deck-IDE-Setup-x.x.x.exe`をダウンロードしてインストール。
+
+### ソースから実行
+
+```bash
+# リポジトリをクローン
+git clone https://github.com/tako0614/ide.git
+cd ide
+
+# 依存関係をインストール
+npm install
+
+# 開発モードで起動（Web + Server）
+npm run dev:server   # ターミナル1
+npm run dev:web      # ターミナル2
+
+# またはビルドして起動
+npm run serve
+```
+
+ブラウザで http://localhost:3210 を開く。
+
+## プロジェクト構成
+
+```
+ide/
+├── apps/
+│   ├── web/          # フロントエンド (React + Vite)
+│   ├── server/       # バックエンド (Hono + node-pty)
+│   └── desktop/      # Electronアプリ
+├── packages/
+│   └── shared/       # 共有型定義
+└── docs/             # ドキュメント
+```
+
+## 技術スタック
+
+### フロントエンド
+- React 19
+- Vite
+- Monaco Editor
+- xterm.js (WebGL対応)
+- TypeScript
+
+### バックエンド
+- Hono (高速HTTPフレームワーク)
+- node-pty (疑似ターミナル)
+- simple-git (Git操作)
+- WebSocket (ターミナル通信)
+- SQLite (データ永続化)
+
+### デスクトップ
+- Electron 40
+- electron-builder
+- electron-updater (自動アップデート)
+
+## 使い方
+
+### ワークスペースの追加
+
+1. 左サイドバーの「+」ボタンをクリック
+2. ディレクトリパスを入力（例: `C:\Projects\myapp`）
+3. ワークスペースが追加される
+
+### デッキの作成
+
+1. ワークスペースを選択
+2. 「デッキ作成」ボタンをクリック
+3. デッキ名を入力
+
+### ターミナルの使用
+
+- 「ターミナル追加」: 新しいターミナルを開く
+- 「Claude」: `claude` コマンドを実行するターミナルを開く
+- 「Codex」: `codex` コマンドを実行するターミナルを開く
+
+### Git操作
+
+1. サイドナビでGitアイコンをクリック
+2. 変更ファイルを確認
+3. 「+」でステージング、「−」でアンステージ
+4. コミットメッセージを入力してコミット
+5. プッシュ/プル/フェッチボタンで同期
+
+## 開発
+
+```bash
+# 依存関係のインストール
+npm install
+
+# 開発サーバー起動
+npm run dev:server   # サーバー (port 3210)
+npm run dev:web      # Web (port 5173)
+
+# ビルド
+npm run build:web    # Webのみ
+npm run build:server # サーバーのみ
+npm run build:desktop # デスクトップアプリ
+
+# デスクトップアプリの開発
+npm run dev:desktop
+```
+
+## 環境変数
+
+サーバーは以下の環境変数をサポートします:
+
+| 変数名 | 説明 | デフォルト |
+|--------|------|-----------|
+| `PORT` | サーバーポート | 3210 |
+| `HOST` | バインドアドレス | localhost |
+| `BASIC_AUTH_USER` | Basic認証ユーザー名 | (なし) |
+| `BASIC_AUTH_PASSWORD` | Basic認証パスワード | (なし) |
+| `CORS_ORIGIN` | CORS許可オリジン | * (開発時) |
+| `DEFAULT_ROOT` | デフォルトルートパス | (なし) |
+
+## API
+
+### ワークスペース
+- `GET /api/workspaces` - ワークスペース一覧
+- `POST /api/workspaces` - ワークスペース作成
+
+### デッキ
+- `GET /api/decks` - デッキ一覧
+- `POST /api/decks` - デッキ作成
+
+### ファイル
+- `GET /api/files` - ファイル一覧
+- `GET /api/file` - ファイル読み込み
+- `PUT /api/file` - ファイル保存
+- `POST /api/file` - ファイル作成
+- `DELETE /api/file` - ファイル削除
+
+### ターミナル
+- `GET /api/terminals` - ターミナル一覧
+- `POST /api/terminals` - ターミナル作成
+- `DELETE /api/terminals/:id` - ターミナル削除
+- `WS /api/terminals/:id` - ターミナル接続
+
+### Git
+- `GET /api/git/status` - Gitステータス
+- `GET /api/git/repos` - リポジトリ一覧
+- `POST /api/git/stage` - ステージング
+- `POST /api/git/unstage` - アンステージ
+- `POST /api/git/commit` - コミット
+- `POST /api/git/push` - プッシュ
+- `POST /api/git/pull` - プル
+- `GET /api/git/diff` - 差分取得
+- `GET /api/git/branches` - ブランチ一覧
+- `POST /api/git/checkout` - ブランチ切り替え
+
+## ライセンス
+
+MIT
+
+## 作者
+
+[tako0614](https://github.com/tako0614)

package/apps/server/dist/config.js

@@ -0,0 +1,77 @@
+import os from 'node:os';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// When running as a global CLI (`deckide`), DECKIDE_DATA_DIR is set to ~/.deckide/
+const globalDataDir = process.env.DECKIDE_DATA_DIR;
+export const SETTINGS_FILE = globalDataDir
+    ? path.join(globalDataDir, 'settings.json')
+    : path.join(__dirname, '..', '..', 'settings.json');
+let fileSettings = {};
+try {
+    const settingsData = fsSync.readFileSync(SETTINGS_FILE, 'utf-8');
+    fileSettings = JSON.parse(settingsData);
+    console.log('[CONFIG] Loaded settings from file');
+}
+catch {
+    // No settings file, use environment variables
+}
+function parseIntEnv(val, defaultVal) {
+    if (typeof val === 'number')
+        return Number.isFinite(val) ? Math.floor(val) : defaultVal;
+    const n = parseInt(val ?? '', 10);
+    return Number.isFinite(n) ? n : defaultVal;
+}
+export const DEFAULT_ROOT = process.env.DEFAULT_ROOT || os.homedir();
+export const PORT = parseIntEnv(process.env.PORT ?? fileSettings.port, 8787);
+export const HOST = process.env.HOST || '0.0.0.0';
+export const BASIC_AUTH_USER = process.env.BASIC_AUTH_USER || (fileSettings.basicAuthEnabled ? fileSettings.basicAuthUser : undefined);
+export const BASIC_AUTH_PASSWORD = process.env.BASIC_AUTH_PASSWORD || (fileSettings.basicAuthEnabled ? fileSettings.basicAuthPassword : undefined);
+export const CORS_ORIGIN = process.env.CORS_ORIGIN;
+export const NODE_ENV = process.env.NODE_ENV || 'development';
+export const MAX_FILE_SIZE = parseIntEnv(process.env.MAX_FILE_SIZE, 10 * 1024 * 1024);
+export const TERMINAL_BUFFER_LIMIT = parseIntEnv(process.env.TERMINAL_BUFFER_LIMIT, 500_000);
+export const MAX_REQUEST_BODY_SIZE = parseIntEnv(process.env.MAX_REQUEST_BODY_SIZE, 1024 * 1024); // 1MB default
+export const TRUST_PROXY = process.env.TRUST_PROXY === 'true'; // Only trust proxy headers if explicitly enabled
+// In packaged app: server is at app.asar.unpacked/server/, web is at app.asar.unpacked/web/dist/
+// In development: server is at apps/server/dist/, web is at apps/web/dist/
+const packagedDistDir = path.resolve(__dirname, '..', 'web', 'dist');
+const devDistDir = path.resolve(__dirname, '..', '..', 'web', 'dist');
+export const distDir = fsSync.existsSync(packagedDistDir) ? packagedDistDir : devDistDir;
+export const hasStatic = fsSync.existsSync(distDir);
+const packagedDataDir = path.resolve(__dirname, '..', 'data');
+const devDataDir = path.resolve(__dirname, '..', '..', 'data');
+export const dataDir = globalDataDir
+    ? globalDataDir
+    : fsSync.existsSync(path.dirname(packagedDataDir)) && !fsSync.existsSync(devDataDir) ? packagedDataDir : devDataDir;
+export const dbPath = process.env.DB_PATH || path.join(dataDir, 'deck-ide.db');
+// Validate critical configuration
+if (NODE_ENV === 'production') {
+    if (!CORS_ORIGIN) {
+        console.error('CRITICAL: CORS_ORIGIN must be set in production!');
+        process.exit(1);
+    }
+    // Validate password strength in production
+    if (BASIC_AUTH_PASSWORD && BASIC_AUTH_PASSWORD.length < 12) {
+        console.error('CRITICAL: BASIC_AUTH_PASSWORD must be at least 12 characters in production!');
+        process.exit(1);
+    }
+    // Warn if no authentication is configured
+    if (!BASIC_AUTH_USER || !BASIC_AUTH_PASSWORD) {
+        console.warn('WARNING: No authentication configured! API is publicly accessible.');
+    }
+}
+// Validate numeric configuration values
+if (!Number.isFinite(PORT) || PORT < 1 || PORT > 65535) {
+    console.error('CRITICAL: Invalid PORT value');
+    process.exit(1);
+}
+if (!Number.isFinite(MAX_FILE_SIZE) || MAX_FILE_SIZE < 1024) {
+    console.error('CRITICAL: Invalid MAX_FILE_SIZE value');
+    process.exit(1);
+}
+// Ensure data directory exists
+fsSync.mkdirSync(path.dirname(dbPath), { recursive: true });
+// PTY daemon info file - written by daemon on startup so server can find its port
+export const daemonInfoPath = path.join(path.dirname(dbPath), 'pty-daemon.json');

package/apps/server/dist/index.js

@@ -0,0 +1,5 @@
+import { createServer } from './server.js';
+createServer().catch((err) => {
+    console.error('Failed to start server:', err);
+    process.exit(1);
+});

package/apps/server/dist/middleware/auth.js

@@ -0,0 +1,78 @@
+import { basicAuth } from 'hono/basic-auth';
+import crypto from 'node:crypto';
+import { BASIC_AUTH_USER, BASIC_AUTH_PASSWORD } from '../config.js';
+export const basicAuthMiddleware = BASIC_AUTH_USER && BASIC_AUTH_PASSWORD
+    ? basicAuth({ username: BASIC_AUTH_USER, password: BASIC_AUTH_PASSWORD })
+    : undefined;
+// WebSocket token management
+const WS_TOKEN_TTL_MS = 30 * 1000; // 30 seconds
+const wsTokens = new Map(); // token -> expiry timestamp
+// Cleanup expired tokens periodically
+setInterval(() => {
+    const now = Date.now();
+    for (const [token, expiry] of wsTokens.entries()) {
+        if (now > expiry) {
+            wsTokens.delete(token);
+        }
+    }
+}, 10000).unref();
+/**
+ * Generate a one-time WebSocket token
+ */
+export function generateWsToken() {
+    const token = crypto.randomBytes(32).toString('hex');
+    wsTokens.set(token, Date.now() + WS_TOKEN_TTL_MS);
+    return token;
+}
+/**
+ * Validate and consume a WebSocket token
+ */
+export function validateWsToken(token) {
+    const expiry = wsTokens.get(token);
+    if (!expiry) {
+        return false;
+    }
+    wsTokens.delete(token); // One-time use
+    return Date.now() <= expiry;
+}
+/**
+ * Check if Basic Auth is enabled
+ */
+export function isBasicAuthEnabled() {
+    return Boolean(BASIC_AUTH_USER && BASIC_AUTH_PASSWORD);
+}
+function timingSafeEqual(a, b) {
+    const aBuf = Buffer.from(a);
+    const bBuf = Buffer.from(b);
+    if (aBuf.length !== bBuf.length) {
+        // Dummy comparison to prevent length-based timing leak
+        crypto.timingSafeEqual(aBuf, aBuf);
+        return false;
+    }
+    return crypto.timingSafeEqual(aBuf, bBuf);
+}
+export function verifyWebSocketAuth(req) {
+    if (!BASIC_AUTH_USER || !BASIC_AUTH_PASSWORD) {
+        return true;
+    }
+    // Check for token in query string first
+    const url = new URL(req.url || '', 'http://localhost');
+    const token = url.searchParams.get('token');
+    if (token && validateWsToken(token)) {
+        return true;
+    }
+    // Fall back to Basic Auth header
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Basic ')) {
+        return false;
+    }
+    const base64Credentials = authHeader.slice('Basic '.length);
+    const credentials = Buffer.from(base64Credentials, 'base64').toString('utf8');
+    const colonIndex = credentials.indexOf(':');
+    if (colonIndex === -1) {
+        return false;
+    }
+    const username = credentials.substring(0, colonIndex);
+    const password = credentials.substring(colonIndex + 1);
+    return timingSafeEqual(username, BASIC_AUTH_USER) && timingSafeEqual(password, BASIC_AUTH_PASSWORD);
+}

package/apps/server/dist/middleware/cors.js

@@ -0,0 +1,26 @@
+import { CORS_ORIGIN, NODE_ENV, PORT } from '../config.js';
+const DEV_ALLOWED_ORIGINS = [
+    'http://localhost:5173',
+    'http://localhost:3000',
+    `http://localhost:${PORT}`,
+];
+export const corsMiddleware = async (c, next) => {
+    if (CORS_ORIGIN) {
+        c.header('Access-Control-Allow-Origin', CORS_ORIGIN);
+    }
+    else if (NODE_ENV === 'development') {
+        const origin = c.req.header('origin');
+        if (origin && DEV_ALLOWED_ORIGINS.includes(origin)) {
+            c.header('Access-Control-Allow-Origin', origin);
+        }
+        else {
+            c.header('Access-Control-Allow-Origin', `http://localhost:${PORT}`);
+        }
+    }
+    c.header('Access-Control-Allow-Methods', 'GET,POST,PUT,OPTIONS');
+    c.header('Access-Control-Allow-Headers', 'Content-Type,Authorization');
+    if (c.req.method === 'OPTIONS') {
+        return c.body(null, 204);
+    }
+    await next();
+};

package/apps/server/dist/middleware/security.js

@@ -0,0 +1,16 @@
+// Security event logging
+export function logSecurityEvent(event, details) {
+    const timestamp = new Date().toISOString();
+    console.warn(`[SECURITY] ${timestamp} ${event}:`, JSON.stringify(details));
+}
+export const securityHeaders = async (c, next) => {
+    c.header('X-Frame-Options', 'DENY');
+    c.header('X-Content-Type-Options', 'nosniff');
+    c.header('X-XSS-Protection', '1; mode=block');
+    c.header('Referrer-Policy', 'strict-origin-when-cross-origin');
+    c.header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+    c.header('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
+    // Allow Monaco Editor from CDN, Google Fonts, and blob: for workers
+    c.header('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.jsdelivr.net blob:; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://fonts.googleapis.com; font-src 'self' https://cdn.jsdelivr.net https://fonts.gstatic.com data:; img-src 'self' data: blob:; connect-src 'self' ws: wss:; worker-src 'self' blob:;");
+    await next();
+};

package/apps/server/dist/pty-client.js

@@ -0,0 +1,177 @@
+/**
+ * PtyClient - IPC client for the main server to communicate with the PTY daemon.
+ * Uses newline-delimited JSON over a local TCP connection.
+ */
+import net from 'node:net';
+import { EventEmitter } from 'node:events';
+export class PtyClient extends EventEmitter {
+    socket = null;
+    lineBuf = '';
+    _connected = false;
+    listCallback = null;
+    shutdownCallback = null;
+    createCallbacks = new Map();
+    get connected() {
+        return this._connected;
+    }
+    connect(port) {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(port, '127.0.0.1');
+            socket.once('connect', () => {
+                this.socket = socket;
+                this._connected = true;
+                resolve();
+            });
+            socket.once('error', (err) => {
+                if (!this._connected) {
+                    reject(err);
+                }
+                else {
+                    this.emit('error', err);
+                }
+            });
+            socket.on('data', (chunk) => {
+                this.lineBuf += chunk.toString('utf8');
+                const lines = this.lineBuf.split('\n');
+                this.lineBuf = lines.pop();
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        this.handleMessage(JSON.parse(line));
+                    }
+                    catch { /* malformed message, ignore */ }
+                }
+            });
+            socket.on('close', () => {
+                this._connected = false;
+                this.socket = null;
+                if (this.shutdownCallback) {
+                    this.shutdownCallback(false);
+                    this.shutdownCallback = null;
+                }
+                this.emit('disconnect');
+            });
+        });
+    }
+    handleMessage(msg) {
+        switch (msg.type) {
+            case 'data':
+                this.emit('data', msg.id, msg.data);
+                break;
+            case 'exit':
+                this.emit('exit', msg.id, msg.code);
+                break;
+            case 'list_result': {
+                const cb = this.listCallback;
+                this.listCallback = null;
+                cb?.(msg.terminals);
+                break;
+            }
+            case 'shutdown_ack': {
+                const cb = this.shutdownCallback;
+                this.shutdownCallback = null;
+                cb?.(true);
+                break;
+            }
+            case 'created': {
+                const cb = this.createCallbacks.get(msg.id);
+                if (cb) {
+                    this.createCallbacks.delete(msg.id);
+                    cb();
+                }
+                break;
+            }
+            case 'error': {
+                if (msg.id) {
+                    const cb = this.createCallbacks.get(msg.id);
+                    if (cb) {
+                        this.createCallbacks.delete(msg.id);
+                        cb(msg.message);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    send(msg) {
+        if (this.socket && !this.socket.destroyed) {
+            try {
+                this.socket.write(JSON.stringify(msg) + '\n');
+            }
+            catch { /* socket may be closing */ }
+        }
+    }
+    /** Spawn a new PTY in the daemon. Resolves when daemon confirms creation. */
+    create(params) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.createCallbacks.delete(params.id);
+                reject(new Error(`Timeout creating terminal ${params.id}`));
+            }, 10_000);
+            this.createCallbacks.set(params.id, (err) => {
+                clearTimeout(timer);
+                if (err)
+                    reject(new Error(err));
+                else
+                    resolve();
+            });
+            this.send({ type: 'create', ...params });
+        });
+    }
+    /** Send keyboard input to a terminal. */
+    input(id, data) {
+        this.send({ type: 'input', id, data });
+    }
+    /** Resize a terminal. */
+    resize(id, cols, rows) {
+        this.send({ type: 'resize', id, cols, rows });
+    }
+    /** Kill a terminal and remove it from the daemon. */
+    kill(id) {
+        this.send({ type: 'kill', id });
+    }
+    /**
+     * Subscribe to live data from a terminal.
+     * The daemon will first send any buffered output since `bufferOffset`,
+     * then stream all subsequent output.
+     */
+    attach(id, bufferOffset) {
+        this.send({ type: 'attach', id, bufferOffset });
+    }
+    /** Get a list of all terminals currently alive in the daemon. */
+    list() {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.listCallback = null;
+                resolve([]);
+            }, 5_000);
+            this.listCallback = (terminals) => {
+                clearTimeout(timer);
+                resolve(terminals);
+            };
+            this.send({ type: 'list' });
+        });
+    }
+    /** Ask the daemon to terminate itself and all child PTYs. */
+    shutdown(timeoutMs = 2_000) {
+        if (!this.connected) {
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.shutdownCallback = null;
+                resolve(false);
+            }, timeoutMs);
+            this.shutdownCallback = (ok) => {
+                clearTimeout(timer);
+                this.shutdownCallback = null;
+                resolve(ok);
+            };
+            this.send({ type: 'shutdown' });
+        });
+    }
+    destroy() {
+        this.socket?.destroy();
+    }
+}