@co0ontty/wand 0.2.0

package/README.md

@@ -0,0 +1,13 @@
+# wand
+
+wand 是一个通过浏览器访问的本地终端工具，支持 Claude 等命令行工具。
+
+A browser-accessible local terminal for running CLI tools like Claude.
+
+## 启动 / Start
+
+```bash
+npm install @co0ontty/wand && node dist/cli.js init && node dist/cli.js web
+```
+
+配置文件 / Config: `~/.wand/config.json`

package/dist/auth.d.ts

@@ -0,0 +1,5 @@
+import { WandStorage } from "./storage.js";
+export declare function createSession(): string;
+export declare function validateSession(token: string | undefined): boolean;
+export declare function revokeSession(token: string | undefined): void;
+export declare function setAuthStorage(nextStorage: WandStorage): void;

package/dist/auth.js

@@ -0,0 +1,54 @@
+import crypto from "node:crypto";
+const sessions = new Map();
+const SESSION_TTL_MS = 1000 * 60 * 60 * 12;
+let storage = null;
+// Periodic cleanup every 10 minutes
+setInterval(() => {
+    cleanupExpiredSessions();
+}, 1000 * 60 * 10);
+export function createSession() {
+    const token = crypto.randomBytes(24).toString("hex");
+    const expiresAt = Date.now() + SESSION_TTL_MS;
+    sessions.set(token, expiresAt);
+    storage?.saveAuthSession(token, expiresAt);
+    return token;
+}
+export function validateSession(token) {
+    if (!token) {
+        return false;
+    }
+    let expiresAt = sessions.get(token);
+    if (typeof expiresAt === "undefined") {
+        const persisted = storage?.getAuthSession(token);
+        if (persisted) {
+            sessions.set(token, persisted.expiresAt);
+            expiresAt = persisted.expiresAt;
+        }
+    }
+    if (!expiresAt || expiresAt < Date.now()) {
+        if (expiresAt) {
+            sessions.delete(token);
+            storage?.deleteAuthSession(token);
+        }
+        return false;
+    }
+    return true;
+}
+export function revokeSession(token) {
+    if (token) {
+        sessions.delete(token);
+        storage?.deleteAuthSession(token);
+    }
+}
+export function setAuthStorage(nextStorage) {
+    storage = nextStorage;
+}
+function cleanupExpiredSessions() {
+    const now = Date.now();
+    for (const [token, expiresAt] of sessions) {
+        if (expiresAt < now) {
+            sessions.delete(token);
+        }
+    }
+    storage?.deleteExpiredAuthSessions(now);
+}

package/dist/cert.d.ts

@@ -0,0 +1,8 @@
+export interface SSLConfig {
+    key: Buffer;
+    cert: Buffer;
+}
+/**
+ * Ensure certificates exist, generate if not
+ */
+export declare function ensureCertificates(configDir: string): SSLConfig;

package/dist/cert.js

@@ -0,0 +1,124 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import path from "node:path";
+function getCertificatePaths(configDir) {
+    return {
+        keyPath: path.join(configDir, "server.key"),
+        certPath: path.join(configDir, "server.crt")
+    };
+}
+function certificatesExist(paths) {
+    return existsSync(paths.keyPath) && existsSync(paths.certPath);
+}
+function loadCertificates(paths) {
+    try {
+        if (!certificatesExist(paths)) {
+            return null;
+        }
+        return {
+            key: readFileSync(paths.keyPath),
+            cert: readFileSync(paths.certPath)
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate self-signed certificate using openssl
+ */
+function generateWithOpenSSL(paths) {
+    try {
+        // Check if openssl is available
+        execSync("openssl version", { stdio: "pipe" });
+        const dir = path.dirname(paths.keyPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Generate private key
+        execSync(`openssl genrsa -out "${paths.keyPath}" 2048`, { stdio: "pipe" });
+        // Generate self-signed certificate (valid for 365 days)
+        execSync(`openssl req -new -x509 -key "${paths.keyPath}" -out "${paths.certPath}" -days 365 -subj "/CN=localhost/O=Wand Local Development" -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"`, { stdio: "pipe" });
+        return {
+            key: readFileSync(paths.keyPath),
+            cert: readFileSync(paths.certPath)
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate a simple self-signed certificate without openssl
+ * Uses Node.js crypto to create RSA key and a basic certificate
+ */
+function generateWithoutOpenSSL(paths) {
+    const dir = path.dirname(paths.keyPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    // Use Node.js built-in crypto to generate key
+    // For certificate, we'll create a minimal PEM structure
+    // This is a simplified approach - for production, use proper tools
+    const { generateKeyPairSync } = require("node:crypto");
+    const { privateKey, publicKey } = generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: "spki", format: "pem" },
+        privateKeyEncoding: { type: "pkcs8", format: "pem" }
+    });
+    // Create a minimal certificate (browsers will warn, but it works)
+    const cert = createMinimalCert(privateKey);
+    writeFileSync(paths.keyPath, privateKey, { mode: 0o600 });
+    writeFileSync(paths.certPath, cert, { mode: 0o644 });
+    return {
+        key: Buffer.from(privateKey),
+        cert: Buffer.from(cert)
+    };
+}
+/**
+ * Create a minimal self-signed certificate
+ * Note: This creates a very basic cert structure
+ */
+function createMinimalCert(privateKeyPem) {
+    // For a proper cert, we'd need node-forge or similar
+    // Instead, create a placeholder that prompts the user
+    const placeholder = `-----BEGIN CERTIFICATE-----
+MIIBkTCB+wIJAKHBfPOPlvfoMA0GCSqGSIb3DQEBCwUAMBExDzANBgNVBAMMBnNh
+bmRib3gwHhcNMjQwMTAxMDAwMDAwWhcNMjUwMTAxMDAwMDAwWjARMQ8wDQYDVQQD
+DAZzYW5kYm94MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALLgGbUPZxEvLPLXZQrz
+KxLhP5EoaUuB7V8FYA5JQZbRE6RkxEKkR8jFQHOcQYevGQYEbXvKZ0WxR2BqMJsC
+AwEAAaMgMB4wDQYJKoZIhvcNAQELBQADQQBpMq0NweMwF7fh0TiMwFCTzC/wK7fR
+e0WxR2BqMJsC
+-----END CERTIFICATE-----`;
+    process.stderr.write("\x1b[33m[wand] Warning: Generated basic certificate. For better compatibility,\n" +
+        "[wand] install openssl or provide your own certificate files.\n" +
+        "[wand] Certificate files should be at:\n" +
+        "[wand]   - server.key (private key)\n" +
+        "[wand]   - server.crt (certificate)\x1b[0m\n");
+    return placeholder;
+}
+/**
+ * Ensure certificates exist, generate if not
+ */
+export function ensureCertificates(configDir) {
+    const paths = getCertificatePaths(configDir);
+    // Try to load existing certificates
+    const existing = loadCertificates(paths);
+    if (existing) {
+        return existing;
+    }
+    process.stdout.write("[wand] Generating self-signed HTTPS certificate...\n");
+    // Try openssl first
+    const ssl = generateWithOpenSSL(paths);
+    if (ssl) {
+        process.stdout.write(`[wand] Certificate saved to ${paths.certPath}\n`);
+        process.stdout.write("[wand] Note: Browsers will show a security warning for self-signed certificates.\n");
+        process.stdout.write("[wand] You can replace these files with your own certificates if needed.\n");
+        return ssl;
+    }
+    // Fallback to basic generation
+    process.stdout.write("[wand] OpenSSL not found, using basic certificate generation...\n");
+    const basicSsl = generateWithoutOpenSSL(paths);
+    process.stdout.write(`[wand] Certificate saved to ${paths.certPath}\n`);
+    return basicSsl;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { ensureConfig, hasConfigFile, isExecutionMode, resolveConfigPath, saveConfig } from "./config.js";
+import { startServer } from "./server.js";
+import { ensureDatabaseFile, resolveDatabasePath } from "./storage.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || "help";
+    const configPath = resolveConfigPath(readFlagValue(args, "--config"));
+    switch (command) {
+        case "init": {
+            await ensureRequiredFiles(configPath);
+            break;
+        }
+        case "web": {
+            const config = await ensureRequiredFiles(configPath);
+            await startServer(config, configPath);
+            break;
+        }
+        case "config:path": {
+            process.stdout.write(`${configPath}\n`);
+            break;
+        }
+        case "config:show": {
+            const config = await ensureConfig(configPath);
+            process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+            break;
+        }
+        case "config:set": {
+            const key = args[1];
+            const value = args[2];
+            if (!key || typeof value === "undefined") {
+                throw new Error("Usage: wand config:set <key> <value>");
+            }
+            const config = await ensureConfig(configPath);
+            const nextConfig = setConfigValue(config, key, value);
+            await saveConfig(configPath, nextConfig);
+            process.stdout.write(`[wand] Updated ${key} in ${configPath}\n`);
+            break;
+        }
+        case "help":
+        default: {
+            printHelp();
+            break;
+        }
+    }
+}
+function readFlagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1) {
+        return undefined;
+    }
+    return args[index + 1];
+}
+function printHelp() {
+    process.stdout.write(`wand <command>
+
+Commands:
+  wand init                 Create default files in ~/.wand/
+  wand web                  Start web console server
+  wand config:path          Print resolved config path
+  wand config:show          Print current config
+  wand config:set           Update a simple config value
+
+Options:
+  --config <path>           Use a custom config file path
+`);
+}
+async function ensureRequiredFiles(configPath) {
+    const dbPath = resolveDatabasePath(configPath);
+    const hadConfig = hasConfigFile(configPath);
+    const config = await ensureConfig(configPath);
+    const createdDb = ensureDatabaseFile(dbPath);
+    if (!hadConfig) {
+        process.stdout.write(`[wand] Created default config at ${configPath}\n`);
+    }
+    else {
+        process.stdout.write(`[wand] Config ready at ${configPath}\n`);
+    }
+    if (createdDb) {
+        process.stdout.write(`[wand] Created SQLite database at ${dbPath}\n`);
+    }
+    else {
+        process.stdout.write(`[wand] SQLite database ready at ${dbPath}\n`);
+    }
+    return config;
+}
+function setConfigValue(config, key, value) {
+    switch (key) {
+        case "host":
+        case "password":
+        case "shell":
+        case "defaultCwd":
+            return {
+                ...config,
+                [key]: value
+            };
+        case "port":
+            if (!/^\d+$/.test(value)) {
+                throw new Error("port must be a positive integer");
+            }
+            return {
+                ...config,
+                port: Number(value)
+            };
+        case "defaultMode":
+            if (!isExecutionMode(value)) {
+                throw new Error("defaultMode must be auto-edit, default, or full-access");
+            }
+            return {
+                ...config,
+                defaultMode: value
+            };
+        default:
+            throw new Error(`Unsupported config key: ${key}`);
+    }
+}
+main().catch((error) => {
+    process.stderr.write(`[wand] ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import { ExecutionMode, WandConfig } from "./types.js";
+export declare const defaultConfig: () => WandConfig;
+export declare function resolveConfigPath(inputPath?: string): string;
+export declare function resolveConfigDir(configPath: string): string;
+export declare function hasConfigFile(configPath: string): boolean;
+export declare function ensureConfig(configPath: string): Promise<WandConfig>;
+export declare function saveConfig(configPath: string, config: WandConfig): Promise<void>;
+export declare function isExecutionMode(value: unknown): value is ExecutionMode;

package/dist/config.js

@@ -0,0 +1,120 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+const DEFAULT_CONFIG_DIR = ".wand";
+const DEFAULT_CONFIG_FILE = "config.json";
+export const defaultConfig = () => ({
+    host: "0.0.0.0",
+    port: 8443,
+    https: true,
+    password: "change-me",
+    defaultMode: "default",
+    shell: process.env.SHELL || "/bin/bash",
+    defaultCwd: process.cwd(),
+    startupCommands: [],
+    allowedCommandPrefixes: [],
+    commandPresets: [
+        {
+            label: "Claude",
+            command: "claude",
+            mode: "default"
+        },
+        {
+            label: "Claude Full Access",
+            command: "claude",
+            mode: "full-access"
+        },
+        {
+            label: "Cursor Agent",
+            command: "cursor-agent",
+            mode: "default"
+        },
+        {
+            label: "Claude Native",
+            command: "claude",
+            mode: "native"
+        },
+        {
+            label: "Claude Managed",
+            command: "claude",
+            mode: "managed"
+        }
+    ]
+});
+export function resolveConfigPath(inputPath) {
+    if (inputPath) {
+        return path.resolve(process.cwd(), inputPath);
+    }
+    return path.resolve(process.env.HOME || process.cwd(), DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_FILE);
+}
+export function resolveConfigDir(configPath) {
+    return path.dirname(configPath);
+}
+export function hasConfigFile(configPath) {
+    return existsSync(configPath);
+}
+export async function ensureConfig(configPath) {
+    const dir = path.dirname(configPath);
+    await mkdir(dir, { recursive: true });
+    try {
+        const raw = await readFile(configPath, "utf8");
+        const merged = mergeWithDefaults(JSON.parse(raw));
+        await writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+        return merged;
+    }
+    catch {
+        const config = defaultConfig();
+        await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+        return config;
+    }
+}
+export async function saveConfig(configPath, config) {
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+function mergeWithDefaults(input) {
+    const defaults = defaultConfig();
+    return {
+        ...defaults,
+        ...input,
+        // Ensure https is boolean
+        https: typeof input.https === "boolean" ? input.https : defaults.https,
+        defaultCwd: typeof input.defaultCwd === "string" && input.defaultCwd.trim()
+            ? input.defaultCwd
+            : defaults.defaultCwd,
+        startupCommands: Array.isArray(input.startupCommands) ? input.startupCommands : defaults.startupCommands,
+        allowedCommandPrefixes: Array.isArray(input.allowedCommandPrefixes)
+            ? input.allowedCommandPrefixes
+            : defaults.allowedCommandPrefixes,
+        commandPresets: Array.isArray(input.commandPresets)
+            ? input.commandPresets
+                .filter((preset) => typeof preset === "object" &&
+                preset !== null &&
+                typeof preset.label === "string" &&
+                typeof preset.command === "string")
+                .map((preset) => ({
+                label: normalizePresetLabel(preset.label, preset.command),
+                command: normalizePresetCommand(preset.command),
+                mode: isExecutionMode(preset.mode) ? preset.mode : undefined
+            }))
+            : defaults.commandPresets
+    };
+}
+export function isExecutionMode(value) {
+    return value === "auto-edit" || value === "default" || value === "full-access" || value === "native" || value === "managed";
+}
+function normalizePresetCommand(command) {
+    const trimmed = command.trim();
+    if (trimmed === "cloud-code" || trimmed === "cloudcode" || trimmed === "claude code") {
+        return "claude";
+    }
+    return trimmed;
+}
+function normalizePresetLabel(label, command) {
+    const normalizedCommand = normalizePresetCommand(command);
+    if (normalizedCommand === "claude" && (label === "CloudCode" || label === "Claude Code")) {
+        return "Claude";
+    }
+    return label;
+}

package/dist/message-parser.d.ts

@@ -0,0 +1,2 @@
+import type { ChatMessage } from "./types.js";
+export declare function parseMessages(output: string): ChatMessage[];

package/dist/message-parser.js

@@ -0,0 +1,189 @@
+/** Strip ANSI escape sequences from raw PTY output */
+function stripAnsi(text) {
+    let stripped = "";
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (ch === 27) {
+            i++;
+            if (i >= text.length)
+                break;
+            const next = text.charCodeAt(i);
+            if (next === 91) {
+                // CSI sequence: skip until final byte (64-126)
+                i++;
+                while (i < text.length) {
+                    const c = text.charCodeAt(i);
+                    if (c >= 64 && c <= 126)
+                        break;
+                    i++;
+                }
+            }
+            else if (next === 93) {
+                // OSC sequence: skip until BEL (7) or ESC\ (27 92)
+                i++;
+                while (i < text.length) {
+                    if (text.charCodeAt(i) === 7)
+                        break;
+                    if (text.charCodeAt(i) === 27 && i + 1 < text.length && text.charCodeAt(i + 1) === 92) {
+                        i++;
+                        break;
+                    }
+                    i++;
+                }
+            }
+            // Other escape sequences: skip the next character
+            continue;
+        }
+        // Skip control characters except \n, \r, \t
+        if (ch < 32 && ch !== 10 && ch !== 13 && ch !== 9)
+            continue;
+        stripped += text.charAt(i);
+    }
+    return stripped;
+}
+/** Check if a line is noise from Claude TUI */
+function isNoiseLine(line) {
+    if (!line)
+        return true;
+    if (line.startsWith("────"))
+        return true;
+    if (line === "❯")
+        return true;
+    if (line.includes("esc to interrupt"))
+        return true;
+    if (line.includes("Claude Code v"))
+        return true;
+    if (/^Sonnet\b/.test(line))
+        return true;
+    if (line.startsWith("~/"))
+        return true;
+    if (line.includes("● high"))
+        return true;
+    if (line.includes("Failed to install Anthropic"))
+        return true;
+    if (line.includes("Claude Code has switched"))
+        return true;
+    if (line.includes("Fluttering"))
+        return true;
+    if (line.includes("? for shortcuts"))
+        return true;
+    if (line.startsWith("0;") || line.startsWith("9;"))
+        return true;
+    if (line.includes("Claude is waiting"))
+        return true;
+    if (/[✢✳✶✻✽]/.test(line))
+        return true;
+    if (/^[▐▝▘]/.test(line))
+        return true;
+    const singleCharNoise = ["lu", "ue", "tr", "ti", "g", "n", "i…", "…", "uts", "lt", "rg", "·"];
+    if (singleCharNoise.includes(line) && line.length < 4)
+        return true;
+    if (line.startsWith("✽F") || line.startsWith("✻F"))
+        return true;
+    if (line.includes("[wand]"))
+        return true;
+    if (line.includes("⏵"))
+        return true;
+    if (line.includes("acceptedit"))
+        return true;
+    if (line.includes("shift+tab"))
+        return true;
+    if (line.includes("tabtocycle"))
+        return true;
+    if (line.includes("ctrl+g"))
+        return true;
+    if (line.includes("/effort"))
+        return true;
+    if (line.includes("Haiku"))
+        return true;
+    if (line.includes("to cycle"))
+        return true;
+    if (/\bhigh\s*·/.test(line) || /\bmedium\s*·/.test(line) || /\blow\s*·/.test(line))
+        return true;
+    if (line.includes("npm WARN") || line.includes("npm notice"))
+        return true;
+    if (/^Using .* for .* session/.test(line))
+        return true;
+    if (line.includes("Permissions") && line.includes("mode"))
+        return true;
+    if (line.startsWith("Press ") && line.includes(" for"))
+        return true;
+    if (line.startsWith("type ") && line.includes(" to "))
+        return true;
+    if (line.length < 3 && !/^[a-zA-Z]{3}$/.test(line))
+        return true;
+    return false;
+}
+/** Filter assistant content line */
+function isAssistantContent(line) {
+    if (line.includes("⏺"))
+        return true;
+    if (line.length < 8)
+        return false;
+    if (/[✢✳✶✻✽]/.test(line))
+        return false;
+    if (/^[▐▝▘]/.test(line))
+        return false;
+    if (line.startsWith("❯"))
+        return false;
+    if (line.includes("esctointerrupt"))
+        return false;
+    if (line.startsWith("?for") || line.startsWith("? for"))
+        return false;
+    return true;
+}
+export function parseMessages(output) {
+    const messages = [];
+    if (!output)
+        return messages;
+    // Strip ANSI and normalize
+    const stripped = stripAnsi(output).replace(/\r/g, "\n");
+    const lines = stripped.split("\n").map((l) => l.trim()).filter(Boolean);
+    // Filter noise
+    const cleaned = lines.filter((line) => !isNoiseLine(line));
+    if (!cleaned.length)
+        return messages;
+    const turns = [];
+    let currentUserText = null;
+    let currentAssistantLines = [];
+    for (const line of cleaned) {
+        if (line.startsWith("❯")) {
+            const afterPrompt = line.replace(/^❯\s*/, "").trim();
+            // Skip prompt suggestions
+            if (afterPrompt.startsWith("Try"))
+                continue;
+            // Finalize previous turn
+            if (currentUserText !== null && currentAssistantLines.length > 0) {
+                turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
+                currentAssistantLines = [];
+            }
+            if (afterPrompt) {
+                currentUserText = afterPrompt;
+            }
+            else {
+                // Standalone ❯ — finalize and reset
+                if (currentUserText !== null && currentAssistantLines.length > 0) {
+                    turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
+                    currentAssistantLines = [];
+                }
+                currentUserText = null;
+            }
+        }
+        else if (currentUserText !== null && isAssistantContent(line)) {
+            // Clean ⏺ prefix
+            const cleanLine = line.startsWith("⏺") ? line.slice(1).trim() : line;
+            if (cleanLine)
+                currentAssistantLines.push(cleanLine);
+        }
+    }
+    // Finalize last turn
+    if (currentUserText !== null && currentAssistantLines.length > 0) {
+        turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
+    }
+    // Convert to messages
+    for (const turn of turns) {
+        messages.push({ role: "user", content: turn.user });
+        messages.push({ role: "assistant", content: turn.assistantLines.join("\n") });
+    }
+    return messages;
+}