@tongil_kim/clautunnel 0.1.9

package/README.md

@@ -0,0 +1,74 @@
+# ClauTunnel
+
+Remote monitoring and control for Claude Code CLI from your mobile device.
+
+## Installation
+
+**npm (Recommended)**
+
+```bash
+npm install -g @tongil_kim/clautunnel
+```
+
+**Homebrew (macOS)**
+
+```bash
+brew tap TongilKim/clautunnel
+brew install clautunnel
+```
+
+## Setup
+
+Run the setup command to configure your Supabase credentials:
+
+```bash
+clautunnel setup
+```
+
+You'll need:
+- **Supabase Project URL**: Dashboard → Settings → API (e.g., `https://xxxx.supabase.co`)
+- **Supabase Anon Key**: Dashboard → Settings → API → `anon` `public` key
+
+## Usage
+
+```bash
+# Authenticate
+clautunnel login
+
+# Start a session
+clautunnel start
+
+# Start in daemon mode (background)
+clautunnel start --daemon
+
+# Prevent sleep while running (macOS)
+clautunnel start --prevent-sleep
+
+# Check status
+clautunnel status
+
+# Stop the daemon
+clautunnel stop
+```
+
+## Features
+
+- Real-time terminal output streaming to mobile
+- Send input from mobile to CLI
+- Push notifications for task completion, errors, and input prompts
+- Automatic reconnection with exponential backoff
+- Sleep prevention option for long-running tasks
+
+## Requirements
+
+- Node.js 18+
+- Claude Code CLI installed
+
+## Links
+
+- [GitHub Repository](https://github.com/TongilKim/clautunnel)
+- [Mobile App](https://github.com/TongilKim/clautunnel/tree/main/apps/mobile)
+
+## License
+
+MIT

package/bin/clautunnel

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/index.js';

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { EventEmitter } from 'events';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { PermissionMode, SlashCommand, ModelInfo, InteractiveCommandData, InteractiveCommandType, InteractiveResult, UserQuestionData, PermissionRequestData, ToolUseData, Session, SessionStatus, Machine, MachineStatus, ImageAttachment } from 'clautunnel-shared';
+
+interface ConfigData {
+    machineId?: string;
+    sessionTokens?: {
+        accessToken: string;
+        refreshToken: string;
+    };
+    supabaseUrl?: string;
+    supabaseAnonKey?: string;
+}
+declare class Config {
+    private configDir;
+    private configFile;
+    private data;
+    constructor(configDir?: string);
+    private loadConfig;
+    private saveConfig;
+    getSupabaseUrl(): string;
+    getSupabaseAnonKey(): string;
+    setSupabaseCredentials(credentials: {
+        url: string;
+        anonKey: string;
+    }): void;
+    isConfigured(): boolean;
+    requireConfiguration(): void;
+    getMachineId(): string | undefined;
+    setMachineId(machineId: string): void;
+    getSessionTokens(): ConfigData['sessionTokens'] | undefined;
+    setSessionTokens(tokens: ConfigData['sessionTokens']): void;
+    setSession(tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }): void;
+    clearSessionTokens(): void;
+}
+declare function getConfig(): Config;
+
+declare class Logger {
+    private silent;
+    private debugEnabled;
+    constructor();
+    private formatTimestamp;
+    private formatMessage;
+    debug(message: string, data?: object): void;
+    info(message: string, data?: object): void;
+    warn(message: string, data?: object): void;
+    error(message: string, data?: object): void;
+}
+declare function getLogger(): Logger;
+
+interface RealtimeClientOptions {
+    supabase: SupabaseClient;
+    sessionId: string;
+}
+declare class RealtimeClient extends EventEmitter {
+    private supabase;
+    private sessionId;
+    private outputChannel;
+    private inputChannel;
+    private presenceChannel;
+    private seq;
+    private realtimeEnabled;
+    constructor(options: RealtimeClientOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    broadcast(content: string): Promise<void>;
+    broadcastMode(mode: PermissionMode): Promise<void>;
+    broadcastCommands(commands: SlashCommand[]): Promise<void>;
+    broadcastModel(model: string): Promise<void>;
+    broadcastModels(models: ModelInfo[]): Promise<void>;
+    broadcastSystem(content: string): Promise<void>;
+    broadcastInteractiveResponse(data: InteractiveCommandData): Promise<void>;
+    broadcastInteractiveConfirm(command: InteractiveCommandType, result: InteractiveResult): Promise<void>;
+    broadcastResumeHistory(historySessionId: string): Promise<void>;
+    broadcastUserQuestion(questionData: UserQuestionData): Promise<void>;
+    broadcastPermissionRequest(requestData: PermissionRequestData): Promise<void>;
+    broadcastToolUse(toolUseData: ToolUseData): Promise<void>;
+    broadcastComplete(): Promise<void>;
+    broadcastSessionTitle(title: string): Promise<void>;
+    broadcastQueued(): Promise<void>;
+    broadcastError(errorMessage: string, errorCode?: string): Promise<void>;
+    getSeq(): number;
+    isConnected(): boolean;
+    isRealtimeEnabled(): boolean;
+}
+
+interface SessionManagerOptions {
+    supabase: SupabaseClient;
+}
+declare class SessionManager {
+    private supabase;
+    constructor(options: SessionManagerOptions);
+    createSession(machineId: string, workingDirectory?: string): Promise<Session>;
+    endSession(sessionId: string): Promise<void>;
+    getSession(sessionId: string): Promise<Session | null>;
+    updateSessionStatus(sessionId: string, status: SessionStatus): Promise<void>;
+    updateSessionModel(sessionId: string, model: string): Promise<void>;
+    updateSdkSessionId(sessionId: string, sdkSessionId: string): Promise<void>;
+    updateSessionTitle(sessionId: string, title: string): Promise<void>;
+}
+
+interface MachineManagerOptions {
+    supabase: SupabaseClient;
+}
+declare class MachineManager {
+    private supabase;
+    constructor(options: MachineManagerOptions);
+    registerMachine(userId: string, name?: string, machineId?: string): Promise<Machine>;
+    getMachine(machineId: string): Promise<Machine | null>;
+    updateMachineStatus(machineId: string, status: MachineStatus): Promise<void>;
+    heartbeat(machineId: string): Promise<void>;
+    listMachines(userId: string): Promise<Machine[]>;
+}
+
+interface DaemonOptions {
+    supabase: SupabaseClient;
+    userId: string;
+    machineId?: string;
+    machineName?: string;
+    cwd: string;
+    hybrid?: boolean;
+}
+declare class Daemon extends EventEmitter {
+    private options;
+    private sdkSession;
+    private sessionManager;
+    private machineManager;
+    private configManager;
+    private realtimeClient;
+    private machine;
+    private session;
+    private running;
+    private commandsBroadcast;
+    private sdkCommandsBroadcast;
+    private titleSet;
+    constructor(options: DaemonOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendPrompt(prompt: string, attachments?: ImageAttachment[]): Promise<void>;
+    isRunning(): boolean;
+    getSession(): Session | null;
+    getMachine(): Machine | null;
+    private broadcastCommands;
+    private broadcastModels;
+}
+
+export { Config, Daemon, Logger, MachineManager, RealtimeClient, SessionManager, getConfig, getLogger };