mobileclaude-agent 0.1.0

package/README.md

@@ -0,0 +1,116 @@
+# MobileClaude Agent
+
+Desktop agent for **MobileIDE** — control Claude Code from your iPhone via Supabase Realtime.
+
+## Requirements
+
+- Node.js 18+
+- [Claude Code CLI](https://code.claude.ai) installed and accessible in PATH
+- A [Supabase](https://supabase.com) project with the schema applied
+
+## Installation
+
+```bash
+npm install -g mobileclaude-agent
+```
+
+Or run locally from this directory:
+
+```bash
+npm install
+npm run build
+```
+
+## Setup
+
+### 1. Apply Supabase Migrations
+
+In your Supabase project → SQL Editor, run in order:
+
+1. `../supabase/migrations/001_initial_schema.sql`
+2. `../supabase/migrations/002_realtime.sql`
+
+Also enable Realtime in Supabase Dashboard → Database → Replication for:
+`prompts`, `results`, `agent_status`, `session_metas`
+
+### 2. Configure the Agent
+
+```bash
+mobileclaude-agent --setup
+```
+
+You'll be prompted for:
+- **Supabase Project URL** — from Project Settings → API
+- **Supabase Anon Key** — public key, safe to share
+- **Supabase Service Role Key** — secret key, stored with `chmod 600`
+- **Your account email + password** — for initial authentication
+
+Config is saved to `~/.mobileclaude/config.json` (chmod 600).
+
+### 3. Start the Agent
+
+```bash
+mobileclaude-agent
+```
+
+The agent will:
+1. Connect to Supabase and restore your session
+2. Start watching `~/.claude/projects/` for Claude Code sessions
+3. Subscribe to new prompts from your iPhone
+4. Send heartbeats every 30s so the iOS app knows you're online
+
+## How It Works
+
+```
+iPhone (iOS App)
+  → INSERT prompt into Supabase `prompts` table (status=pending)
+
+Desktop Agent
+  → Receives prompt via Supabase Realtime
+  → Checks freemium quota (1 prompt/day free)
+  → Spawns: claude --print --dangerously-skip-permissions --output-format stream-json
+  → Streams output to `results` table every ~500 bytes
+  → iOS app receives live updates via Realtime
+
+On completion:
+  → status=done, session_id saved back to prompts table
+  → iOS can send follow-up prompts with --resume
+```
+
+## Session Indexing
+
+The agent watches `~/.claude/projects/**/*.jsonl` and syncs all Claude Code sessions (including those started in the terminal) to Supabase. This makes them visible in the iOS app's session list — tap any session to continue it from your iPhone.
+
+## Freemium Model
+
+- **Free tier**: 1 prompt per day
+- **Premium**: Unlimited (set by iOS app after StoreKit purchase)
+
+The freemium gate is enforced server-side via the `check_and_increment_daily_usage` PostgreSQL function, using the service role key. The iOS app cannot forge its own count.
+
+## Development
+
+```bash
+npm run dev         # Run with tsx (no build step)
+npm run test:types  # TypeScript type check
+npm test            # Run Jest unit tests
+npm run build       # Compile to dist/
+```
+
+## Autostart
+
+The agent will prompt you to enable autostart during setup. This uses:
+- **macOS**: LaunchAgent plist (`~/Library/LaunchAgents/`)
+- **Windows**: Registry run key (via node-auto-launch)
+- **Linux**: XDG autostart entry (`~/.config/autostart/`)
+
+## System Tray
+
+On desktop systems with a GUI, a system tray icon shows agent status. On headless servers, the agent runs without a tray (no error, just a log message).
+
+## Security Notes
+
+- The service role key bypasses Supabase RLS — keep it secret
+- `~/.mobileclaude/config.json` is `chmod 600` — only your user can read it
+- `--dangerously-skip-permissions` is required for unattended claude CLI execution
+- The freemium gate uses `SECURITY DEFINER` PostgreSQL function to prevent tampering

package/dist/agent_controller.js

@@ -0,0 +1,260 @@
+/**
+ * agent_controller.ts — Core agent logic
+ *
+ * 1. Subscribes to Supabase Realtime for new pending prompts
+ * 2. Polls on startup to catch prompts missed while offline
+ * 3. Enforces freemium gate via daily_usage DB function
+ * 4. Spawns claude CLI, streams output to results table
+ * 5. On completion: sets status=done, upserts session_id back to prompt
+ */
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { supabase } from './supabase.js';
+import { findClaudeBinary, getEnhancedPath } from './platform.js';
+const FREE_DAILY_LIMIT = 10;
+const STREAM_FLUSH_BYTES = 500;
+let isProcessing = false;
+const pendingQueue = [];
+let channel = null;
+let claudeBinary = null;
+let currentConfig;
+export function initAgentController(config, platform) {
+    currentConfig = config;
+    claudeBinary = findClaudeBinary();
+    if (!claudeBinary) {
+        console.error('❌ Claude CLI not found. Install it with:\n' +
+            '   npm install -g @anthropic-ai/claude-code\n' +
+            'Then run: mobileclaude-agent');
+        process.exit(1);
+    }
+    console.log(`✓ Claude binary: ${claudeBinary}`);
+}
+/** Start listening for pending prompts via Realtime + initial poll */
+export async function startAgentController() {
+    // 1. Poll on startup — catch anything queued while offline
+    await pollPendingPrompts();
+    // 2. Subscribe to Realtime inserts on prompts table
+    channel = supabase
+        .channel('agent-prompts')
+        .on('postgres_changes', {
+        event: 'INSERT',
+        schema: 'public',
+        table: 'prompts',
+        filter: `user_id=eq.${currentConfig.relayToken}`,
+    }, (payload) => {
+        const prompt = payload.new;
+        if (prompt.status === 'pending') {
+            enqueuePrompt(prompt);
+        }
+    })
+        .subscribe((status) => {
+        if (status === 'SUBSCRIBED') {
+            console.log('✓ Subscribed to prompts channel');
+        }
+    });
+}
+export async function stopAgentController() {
+    if (channel) {
+        await supabase.removeChannel(channel);
+        channel = null;
+    }
+}
+async function pollPendingPrompts() {
+    const { data, error } = await supabase
+        .from('prompts')
+        .select('*')
+        .eq('user_id', currentConfig.relayToken)
+        .eq('status', 'pending')
+        .order('created_at', { ascending: true });
+    if (error) {
+        console.error('Failed to poll pending prompts:', error.message);
+        return;
+    }
+    for (const prompt of data ?? []) {
+        enqueuePrompt(prompt);
+    }
+}
+function enqueuePrompt(prompt) {
+    if (isProcessing) {
+        pendingQueue.push(prompt);
+        console.log(`Queued prompt ${prompt.prompt_id} (queue length: ${pendingQueue.length})`);
+        return;
+    }
+    processPrompt(prompt);
+}
+async function processPrompt(prompt) {
+    isProcessing = true;
+    console.log(`\n→ Processing prompt ${prompt.prompt_id}: "${prompt.prompt_text.slice(0, 60)}..."`);
+    try {
+        // 1. Freemium gate
+        const allowed = await checkFreemiumGate(currentConfig.relayToken);
+        if (!allowed) {
+            await markPromptError(prompt.prompt_id, 'Daily free limit reached. Upgrade to Premium for unlimited prompts.');
+            return;
+        }
+        // 2. Mark as processing
+        await supabase
+            .from('prompts')
+            .update({ status: 'processing' })
+            .eq('prompt_id', prompt.prompt_id);
+        // 3. Create result row upfront so iOS can subscribe before streaming starts
+        const resultId = randomUUID();
+        await supabase.from('results').insert({
+            result_id: resultId,
+            user_id: currentConfig.relayToken,
+            prompt_id: prompt.prompt_id,
+            session_id: prompt.session_id || '',
+            output_text: '',
+            is_final: false,
+        });
+        // 4. Execute claude CLI
+        const { sessionId, outputText, error: execError } = await executeClaudeCli(prompt, resultId);
+        if (execError) {
+            await markPromptError(prompt.prompt_id, execError);
+            await supabase
+                .from('results')
+                .update({ output_text: `Error: ${execError}`, is_final: true })
+                .eq('result_id', resultId);
+            return;
+        }
+        // 5. Final updates
+        const resolvedSessionId = sessionId || prompt.session_id || '';
+        await Promise.all([
+            supabase
+                .from('prompts')
+                .update({ status: 'done', session_id: resolvedSessionId })
+                .eq('prompt_id', prompt.prompt_id),
+            supabase
+                .from('results')
+                .update({ output_text: outputText, session_id: resolvedSessionId, is_final: true })
+                .eq('result_id', resultId),
+        ]);
+        console.log(`✓ Prompt ${prompt.prompt_id} completed (session: ${resolvedSessionId})`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error processing prompt ${prompt.prompt_id}:`, msg);
+        await markPromptError(prompt.prompt_id, msg);
+    }
+    finally {
+        isProcessing = false;
+        const next = pendingQueue.shift();
+        if (next)
+            processPrompt(next);
+    }
+}
+/** Build claude CLI arguments from a prompt row */
+export function buildClaudeArgs(prompt) {
+    const args = [
+        '--print',
+        '--dangerously-skip-permissions',
+        '--output-format', 'stream-json',
+        '--verbose',
+    ];
+    if (prompt.model && prompt.model !== 'default') {
+        args.push('--model', prompt.model);
+    }
+    if (prompt.session_id && prompt.session_id !== '') {
+        args.push('--resume', prompt.session_id);
+    }
+    return args;
+}
+async function executeClaudeCli(prompt, resultId) {
+    return new Promise((resolve) => {
+        const args = buildClaudeArgs(prompt);
+        const cwd = prompt.project_path || process.cwd();
+        const child = spawn(claudeBinary, args, {
+            cwd,
+            env: {
+                ...process.env,
+                PATH: getEnhancedPath(),
+                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ?? '',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdin.write(prompt.prompt_text);
+        child.stdin.end();
+        let stdoutBuffer = '';
+        let textAccumulator = '';
+        let bytesSinceFlush = 0;
+        let detectedSessionId = null;
+        child.stdout.on('data', async (chunk) => {
+            stdoutBuffer += chunk.toString('utf-8');
+            bytesSinceFlush += chunk.length;
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    extractTextFromStreamEvent(obj, (text) => { textAccumulator += text; });
+                    if (obj.type === 'result' && typeof obj.session_id === 'string') {
+                        detectedSessionId = obj.session_id;
+                    }
+                }
+                catch { /* non-JSON line — ignore */ }
+            }
+            if (bytesSinceFlush >= STREAM_FLUSH_BYTES) {
+                bytesSinceFlush = 0;
+                await supabase
+                    .from('results')
+                    .update({ output_text: textAccumulator })
+                    .eq('result_id', resultId);
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            console.error('[claude stderr]', chunk.toString('utf-8').trim());
+        });
+        child.on('close', (code) => {
+            resolve({
+                sessionId: detectedSessionId,
+                outputText: textAccumulator,
+                error: code !== 0 ? `Claude exited with code ${code}` : null,
+            });
+        });
+        child.on('error', (err) => {
+            resolve({ sessionId: null, outputText: '', error: err.message });
+        });
+    });
+}
+function extractTextFromStreamEvent(obj, append) {
+    if (obj.type === 'assistant') {
+        const content = obj.message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                const b = block;
+                if (b.type === 'text' && typeof b.text === 'string')
+                    append(b.text);
+            }
+        }
+    }
+    if (obj.type === 'content_block_delta') {
+        const delta = obj.delta;
+        if (delta?.type === 'text_delta' && typeof delta.text === 'string')
+            append(delta.text);
+    }
+}
+/** Atomically check and increment daily usage via SECURITY DEFINER function */
+async function checkFreemiumGate(relayToken) {
+    const today = new Date().toISOString().slice(0, 10);
+    const { data, error } = await supabase.rpc('check_and_increment_daily_usage', {
+        p_user_id: relayToken,
+        p_date: today,
+        p_free_limit: FREE_DAILY_LIMIT,
+    });
+    if (error) {
+        // Function not deployed — allow prompt
+        console.warn('Freemium gate unavailable (allowing prompt):', error.message);
+        return true;
+    }
+    return data === true;
+}
+async function markPromptError(promptId, message) {
+    await supabase
+        .from('prompts')
+        .update({ status: 'error' })
+        .eq('prompt_id', promptId);
+    console.error(`✗ Prompt ${promptId} error: ${message}`);
+}
+//# sourceMappingURL=agent_controller.js.map

package/dist/config.js

@@ -0,0 +1,49 @@
+/**
+ * config.ts — Agent configuration
+ *
+ * Supabase credentials are baked in at publish time — users never enter them.
+ * Identity = relay token (UUID stored in ~/.mobileclaude/token).
+ * No login, no Supabase account required from the user.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+// ─── BAKED-IN BACKEND CREDENTIALS ────────────────────────────────────────────
+// These point to the developer's Supabase project — same for every user.
+// Replace with your real values before `npm publish`.
+export const SUPABASE_URL = process.env.MOBILECLAUDE_SUPABASE_URL
+    ?? 'https://zxmgprkewaejozfezpwx.supabase.co';
+export const SUPABASE_ANON_KEY = process.env.MOBILECLAUDE_SUPABASE_ANON_KEY
+    ?? 'sb_publishable_C9DAeRtk0fPPuhau1Iw4OQ_k75bz8kC';
+// ─────────────────────────────────────────────────────────────────────────────
+export const AGENT_VERSION = '0.1.0';
+// Relay token file — permanent device identity, created once
+const configDir = join(homedir(), '.mobileclaude');
+const tokenPath = join(configDir, 'token');
+export function getRelayToken() {
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    if (existsSync(tokenPath)) {
+        const saved = readFileSync(tokenPath, 'utf-8').trim();
+        if (saved.length > 0)
+            return saved;
+    }
+    // Generate new UUID token
+    const token = crypto.randomUUID();
+    writeFileSync(tokenPath, token, 'utf-8');
+    return token;
+}
+export function loadConfig() {
+    return {
+        supabaseUrl: SUPABASE_URL,
+        supabaseAnonKey: SUPABASE_ANON_KEY,
+        relayToken: getRelayToken(),
+        agentVersion: AGENT_VERSION,
+        maxConcurrentPrompts: 1,
+    };
+}
+// Legacy — keep for backwards compat, but no longer used
+export function configExists() { return true; }
+export async function runSetupWizard() { return loadConfig(); }
+//# sourceMappingURL=config.js.map

package/dist/heartbeat.js

@@ -0,0 +1,44 @@
+/**
+ * heartbeat.ts — Sends periodic heartbeats to agent_status table.
+ * iOS shows "Mac offline" banner if last_heartbeat > 60s ago.
+ */
+import { supabase } from './supabase.js';
+import { getPlatform } from './platform.js';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const AGENT_VERSION = '0.1.0';
+let heartbeatTimer = null;
+let relayToken;
+let sessionCount = 0;
+export function incrementSessionCount() {
+    sessionCount++;
+}
+export async function startHeartbeat(config) {
+    relayToken = config.relayToken;
+    await sendHeartbeat(true);
+    heartbeatTimer = setInterval(() => { sendHeartbeat(true); }, HEARTBEAT_INTERVAL_MS);
+}
+export function stopHeartbeat() {
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
+    // Fire-and-forget offline signal
+    sendHeartbeat(false).catch(() => { });
+}
+async function sendHeartbeat(isOnline) {
+    const platform = getPlatform();
+    const { error } = await supabase
+        .from('agent_status')
+        .upsert({
+        user_id: relayToken,
+        is_online: isOnline,
+        platform,
+        agent_version: AGENT_VERSION,
+        last_heartbeat: new Date().toISOString(),
+        session_count: sessionCount,
+    }, { onConflict: 'user_id' });
+    if (error) {
+        console.warn('Heartbeat error:', error.message);
+    }
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * index.ts — MobileClaude Agent entry point
+ *
+ * No setup required — credentials are baked in.
+ * Just run: npx mobileclaude-agent
+ */
+import { loadConfig } from './config.js';
+import { initSupabase } from './supabase.js';
+import { initAgentController, startAgentController, stopAgentController } from './agent_controller.js';
+import { startSessionIndexer, stopSessionIndexer } from './session_indexer.js';
+import { startHeartbeat, stopHeartbeat } from './heartbeat.js';
+import { startTray, stopTray } from './tray.js';
+import { getPlatform, findClaudeBinary } from './platform.js';
+async function main() {
+    const { default: chalk } = await import('chalk');
+    console.log(chalk.bold.cyan('🤖 MobileClaude Agent v0.1.0'));
+    console.log(chalk.dim('  Remote Claude Code control from your iPhone\n'));
+    // ── Load config (baked-in credentials + relay token) ─────────────────────
+    const config = loadConfig();
+    console.log(chalk.dim(`  Relay token: ${config.relayToken.slice(0, 8)}...`));
+    // ── Initialize Supabase ───────────────────────────────────────────────────
+    initSupabase(config);
+    // ── Validate claude binary ────────────────────────────────────────────────
+    const claude = findClaudeBinary();
+    if (!claude) {
+        console.error(chalk.red('❌ Claude CLI not found. Install it with:'));
+        console.error(chalk.dim('   npm install -g @anthropic-ai/claude-code'));
+        process.exit(1);
+    }
+    console.log(chalk.green(`✓ Claude CLI: ${claude}`));
+    // ── Start subsystems ──────────────────────────────────────────────────────
+    const platform = getPlatform();
+    initAgentController(config, platform);
+    console.log('\nStarting agent subsystems...');
+    await startHeartbeat(config);
+    console.log(chalk.green('✓ Heartbeat started (30s interval)'));
+    startSessionIndexer(config);
+    console.log(chalk.green('✓ Session indexer watching ~/.claude/projects/'));
+    await startAgentController();
+    console.log(chalk.green('✓ Agent controller listening for prompts'));
+    await startTray(() => gracefulShutdown());
+    const platformName = { darwin: 'macOS', win32: 'Windows', linux: 'Linux' }[platform] ?? platform;
+    console.log(chalk.bold.green(`\n✓ Agent running on ${platformName} — waiting for prompts from iPhone\n`));
+    console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+    // ── Graceful shutdown ─────────────────────────────────────────────────────
+    process.on('SIGTERM', gracefulShutdown);
+    process.on('SIGINT', gracefulShutdown);
+}
+let shuttingDown = false;
+async function gracefulShutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    const { default: chalk } = await import('chalk');
+    console.log(chalk.yellow('\nShutting down agent...'));
+    stopHeartbeat();
+    stopSessionIndexer();
+    await stopAgentController();
+    stopTray();
+    console.log(chalk.green('✓ Agent stopped cleanly'));
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/platform.js

@@ -0,0 +1,107 @@
+/**
+ * platform.ts — OS detection and platform-specific paths/utilities
+ * Supports macOS (darwin), Windows (win32), and Linux.
+ */
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { execSync } from 'child_process';
+export function getPlatform() {
+    const p = process.platform;
+    if (p === 'darwin' || p === 'win32' || p === 'linux')
+        return p;
+    return 'linux'; // fallback
+}
+/** ~/.claude/projects/ — where Claude Code stores session JSONL files */
+export function claudeProjectsDir() {
+    return join(homedir(), '.claude', 'projects');
+}
+/** ~/.mobileclaude/ — config directory for this agent */
+export function agentConfigDir() {
+    return join(homedir(), '.mobileclaude');
+}
+/** Full path to the agent's config file */
+export function agentConfigPath() {
+    return join(agentConfigDir(), 'config.json');
+}
+/** Full path to the agent's log file */
+export function agentLogPath() {
+    return join(agentConfigDir(), 'agent.log');
+}
+/**
+ * Finds the claude CLI binary on the current system.
+ * Checks PATH first, then common install locations for nvm/fnm/mise/brew.
+ * Returns null if not found.
+ */
+export function findClaudeBinary() {
+    // 1. Try PATH
+    try {
+        const result = execSync('which claude 2>/dev/null || where claude 2>/dev/null', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (result && existsSync(result))
+            return result;
+    }
+    catch {
+        // not on PATH
+    }
+    // 2. Try common macOS/Linux install paths
+    const commonPaths = [];
+    const home = homedir();
+    if (process.platform !== 'win32') {
+        commonPaths.push('/usr/local/bin/claude', '/usr/bin/claude', '/opt/homebrew/bin/claude', join(home, '.local/bin/claude'), join(home, '.npm-global/bin/claude'), 
+        // nvm
+        join(home, '.nvm/versions/node/*/bin/claude'), 
+        // fnm
+        join(home, '.fnm/node-versions/*/installation/bin/claude'), 
+        // mise (formerly rtx)
+        join(home, '.local/share/mise/shims/claude'), 
+        // pnpm global
+        join(home, '.local/share/pnpm/claude'));
+    }
+    else {
+        // Windows common paths
+        const appData = process.env.APPDATA ?? '';
+        const localAppData = process.env.LOCALAPPDATA ?? '';
+        commonPaths.push(join(appData, 'npm', 'claude.cmd'), join(localAppData, 'pnpm', 'claude.cmd'), 'C:\\Program Files\\nodejs\\claude.cmd');
+    }
+    for (const p of commonPaths) {
+        // Handle glob patterns (simple expansion for *)
+        if (p.includes('*')) {
+            try {
+                const globResult = execSync(`ls ${p} 2>/dev/null | head -1`, {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                if (globResult && existsSync(globResult))
+                    return globResult;
+            }
+            catch {
+                // skip
+            }
+        }
+        else if (existsSync(p)) {
+            return p;
+        }
+    }
+    return null;
+}
+/**
+ * Returns the PATH string to use when spawning child processes.
+ * On macOS/Linux, sources common shell locations so claude is found
+ * even when the agent runs as a LaunchAgent/systemd service.
+ */
+export function getEnhancedPath() {
+    const home = homedir();
+    const extraPaths = [
+        '/usr/local/bin',
+        '/opt/homebrew/bin',
+        join(home, '.local/bin'),
+        join(home, '.npm-global/bin'),
+        join(home, '.local/share/pnpm'),
+    ];
+    const currentPath = process.env.PATH ?? '';
+    return [...extraPaths, currentPath].join(':');
+}
+//# sourceMappingURL=platform.js.map

package/dist/session_indexer.js

@@ -0,0 +1,119 @@
+/**
+ * session_indexer.ts — Watches ~/.claude/projects/ for JSONL files
+ * and upserts session metadata to Supabase.
+ *
+ * Makes ALL Claude Code sessions (including desktop-created ones)
+ * visible in the iOS app.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { basename, dirname } from 'path';
+import chokidar from 'chokidar';
+import { supabase } from './supabase.js';
+import { claudeProjectsDir } from './platform.js';
+let watcher = null;
+let relayToken;
+export function startSessionIndexer(config) {
+    relayToken = config.relayToken;
+    const watchDir = claudeProjectsDir();
+    if (!existsSync(watchDir)) {
+        console.log('Session indexer: ~/.claude/projects/ not found yet, will watch once created');
+    }
+    watcher = chokidar.watch(`${watchDir}/**/*.jsonl`, {
+        persistent: true,
+        ignoreInitial: false,
+        depth: 3,
+        awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
+    });
+    watcher
+        .on('add', (filePath) => { parseAndUpsertSession(filePath, false); })
+        .on('change', (filePath) => { parseAndUpsertSession(filePath, false); })
+        .on('error', (err) => { console.error('Session indexer watcher error:', err); })
+        .on('ready', () => { console.log('✓ Session indexer watching ~/.claude/projects/'); });
+}
+export function stopSessionIndexer() {
+    watcher?.close();
+    watcher = null;
+}
+export async function parseAndUpsertSession(filePath, startedFromMobile) {
+    if (!existsSync(filePath))
+        return;
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    const parsed = parseJSONLSession(raw);
+    if (!parsed)
+        return;
+    const meta = {
+        session_id: parsed.sessionId,
+        user_id: relayToken,
+        project_path: parsed.projectPath,
+        project_name: parsed.projectName,
+        first_prompt: parsed.firstPrompt,
+        last_prompt: parsed.lastPrompt,
+        message_count: parsed.messageCount,
+        model: parsed.model,
+        started_from_mobile: startedFromMobile,
+        created_at: parsed.createdAt,
+        updated_at: parsed.updatedAt,
+    };
+    const { error } = await supabase
+        .from('session_metas')
+        .upsert(meta, { onConflict: 'session_id', ignoreDuplicates: false });
+    if (error) {
+        console.error(`Session indexer upsert error for ${basename(filePath)}:`, error.message);
+    }
+}
+export function parseJSONLSession(raw) {
+    const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+    const entries = [];
+    for (const line of lines) {
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch { /* malformed line — skip */ }
+    }
+    if (entries.length === 0)
+        return null;
+    const userEntries = entries.filter((e) => e.type === 'user' &&
+        e.message !== null &&
+        typeof e.message === 'object' &&
+        typeof e.message.content === 'string');
+    if (userEntries.length === 0)
+        return null;
+    const assistantEntries = entries.filter((e) => e.type === 'assistant');
+    const firstEntry = userEntries[0];
+    const lastEntry = userEntries[userEntries.length - 1];
+    const sessionId = String(firstEntry.sessionId ?? '');
+    if (!sessionId)
+        return null;
+    const projectPath = String(firstEntry.cwd ?? '');
+    const projectName = projectPath
+        ? basename(dirname(projectPath + '/x')) || basename(projectPath)
+        : null;
+    const firstPromptFull = String(firstEntry.message.content ?? '');
+    const lastPromptFull = String(lastEntry.message.content ?? '');
+    let model = null;
+    if (assistantEntries.length > 0) {
+        const msg = assistantEntries[0].message;
+        if (msg && typeof msg.model === 'string')
+            model = msg.model;
+    }
+    const createdAt = String(firstEntry.timestamp ?? new Date().toISOString());
+    const updatedAt = String(entries[entries.length - 1].timestamp ?? createdAt);
+    return {
+        sessionId,
+        projectPath,
+        projectName,
+        firstPrompt: firstPromptFull.slice(0, 200) || null,
+        lastPrompt: lastPromptFull.slice(0, 200) || null,
+        messageCount: userEntries.length + assistantEntries.length,
+        model,
+        createdAt,
+        updatedAt,
+    };
+}
+//# sourceMappingURL=session_indexer.js.map

package/dist/supabase.js

@@ -0,0 +1,14 @@
+/**
+ * supabase.ts — Supabase client (single anon-key client, no auth)
+ *
+ * Identity = relay token (UUID in ~/.mobileclaude/token).
+ * All tables have permissive RLS for the anon role.
+ */
+import { createClient } from '@supabase/supabase-js';
+export let supabase;
+export function initSupabase(config) {
+    supabase = createClient(config.supabaseUrl, config.supabaseAnonKey, {
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+}
+//# sourceMappingURL=supabase.js.map

package/dist/tray.js

@@ -0,0 +1,104 @@
+/**
+ * tray.ts — Optional system tray icon (macOS/Windows/Linux with GUI).
+ * Falls back to headless mode if node-systray2 is unavailable.
+ *
+ * node-systray2 is an optionalDependency — if native compilation fails
+ * (e.g., on headless servers or CI), the agent continues without a tray.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let trayInstance = null;
+export async function startTray(onQuit) {
+    try {
+        // Dynamic import of optional dep — TypeScript can't verify this statically
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = await import('node-systray2');
+        const Systray = mod.default ?? mod;
+        const systray = new Systray({
+            menu: {
+                icon: getIconBase64(),
+                title: 'MobileClaude',
+                tooltip: 'MobileClaude Agent',
+                items: [
+                    {
+                        title: 'MobileClaude Agent v0.1.0',
+                        tooltip: 'Agent version',
+                        enabled: false,
+                        click: () => { },
+                    },
+                    Systray.separator ?? { title: '—', enabled: false, click: () => { } },
+                    {
+                        title: '● Status: running',
+                        tooltip: 'Agent online status',
+                        enabled: false,
+                        click: () => { },
+                    },
+                    Systray.separator ?? { title: '—', enabled: false, click: () => { } },
+                    {
+                        title: 'Stop Agent',
+                        tooltip: 'Stop the agent',
+                        enabled: true,
+                        click: onQuit,
+                    },
+                    {
+                        title: 'Open Logs',
+                        tooltip: 'Open agent log file',
+                        enabled: true,
+                        click: () => openLogs(),
+                    },
+                    Systray.separator ?? { title: '—', enabled: false, click: () => { } },
+                    {
+                        title: 'Quit',
+                        tooltip: 'Quit MobileClaude Agent',
+                        enabled: true,
+                        click: onQuit,
+                    },
+                ],
+            },
+            debug: false,
+            copyDir: true,
+        });
+        trayInstance = systray;
+        console.log('✓ System tray started');
+    }
+    catch {
+        console.log('System tray not available — running headlessly (no GUI required)');
+    }
+}
+export function stopTray() {
+    if (trayInstance && typeof trayInstance.kill === 'function') {
+        try {
+            trayInstance.kill(true);
+        }
+        catch {
+            // ignore errors during tray shutdown
+        }
+    }
+    trayInstance = null;
+}
+function openLogs() {
+    import('./platform.js').then(({ agentLogPath }) => {
+        const path = agentLogPath();
+        import('child_process').then(({ execSync }) => {
+            try {
+                if (process.platform === 'darwin') {
+                    execSync(`open "${path}"`);
+                }
+                else if (process.platform === 'win32') {
+                    execSync(`start "" "${path}"`);
+                }
+                else {
+                    execSync(`xdg-open "${path}" 2>/dev/null || true`);
+                }
+            }
+            catch {
+                console.log(`Log file: ${path}`);
+            }
+        });
+    });
+}
+/** Minimal 16x16 transparent PNG as base64 for the tray icon placeholder */
+function getIconBase64() {
+    // In production, replace with actual app icon (16x16 PNG, base64 encoded)
+    return 'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAB3RJTUUH6AELEAgSO5GSTQAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAAZklEQVQ4y2NgGAWkgP9EMP8z/P//nxgNZP//E6X5H6T5PzHO+E+M5v9E2f+JMP8TY/s/Eb7/R4T9nwjf/yPC/k+E7f8RYf8nwvb/iLD/E2H7f0TY/4mw/T8i7P9E2P4fUQMANyYtJpBzSj8AAAAASUVORK5CYII=';
+}
+//# sourceMappingURL=tray.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mobileclaude-agent",
+  "version": "0.1.0",
+  "description": "Desktop agent for MobileIDE — controls Claude Code from your iPhone via Supabase",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mobileclaude-agent": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test:types": "tsc --noEmit",
+    "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.103.0",
+    "chokidar": "^4.0.0",
+    "chalk": "^5.3.0"
+  },
+  "optionalDependencies": {
+    "node-systray2": "^2.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/node": "^22.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.6.0"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "mobile",
+    "ios",
+    "agent",
+    "supabase"
+  ],
+  "license": "MIT"
+}