newmark-agent 0.4.5 → 0.4.7

package/dist/server.js

@@ -37,6 +37,7 @@ exports.runServer = runServer;
 const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const uiPreferences_1 = require("./core/uiPreferences");
 const child_process_1 = require("child_process");
 const agent_1 = require("./core/agent");
@@ -45,10 +46,187 @@ const config_1 = require("./core/config");
 const flow_1 = require("./core/flow");
 const workspaceFileRouter_1 = require("./core/workspaceFileRouter");
 const nativeBash_1 = require("./core/nativeBash");
+const installUpdate_1 = require("./core/installUpdate");
+const mobilePairing_1 = require("./core/mobilePairing");
 const PORT = 47890;
 let agent = null;
 let automation = null;
 let workspaceFileRouter = null;
+let mobileToken = '';
+let appRoot = '';
+const mobileWorkEventSubscribers = new Set();
+const mobileScopedRuntimes = new Map();
+function mobileRuntimeKey(workspaceId, conversationId) {
+    return `${String(workspaceId || '')}::${String(conversationId || '')}`;
+}
+function publishMobileWorkEvent(event) {
+    for (const subscriber of mobileWorkEventSubscribers) {
+        try {
+            subscriber(event);
+        }
+        catch { /* ignore disconnected mobile listeners */ }
+    }
+}
+function mobileAuthorized(req) {
+    if (!mobileToken)
+        return false;
+    const bearer = String(req.headers.authorization || '');
+    if (bearer.startsWith('Bearer '))
+        return bearer.slice('Bearer '.length).trim() === mobileToken;
+    try {
+        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+        const queryToken = url.searchParams.get('token') || '';
+        return queryToken === mobileToken;
+    }
+    catch {
+        return false;
+    }
+}
+function mobileJson(res, data, code = 200) {
+    const body = JSON.stringify(data);
+    res.writeHead(code, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Access-Control-Allow-Origin': '*',
+    });
+    res.end(body);
+}
+function resolveMobileWorkspace(current, workspaceId) {
+    const clean = String(workspaceId || '');
+    return [...current.workspace.internal, ...current.workspace.external].find(workspace => workspace.id === clean)
+        || (current.workspace.current?.id === clean ? current.workspace.current : null);
+}
+const MOBILE_EDITABLE_EXTENSIONS = new Set([
+    '.txt', '.md', '.markdown', '.json', '.jsonc', '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf',
+    '.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.css', '.scss', '.html', '.htm', '.xml', '.svg',
+    '.kt', '.kts', '.java', '.py', '.rb', '.rs', '.go', '.c', '.h', '.cpp', '.hpp', '.cs', '.sh',
+    '.bash', '.zsh', '.ps1', '.bat', '.cmd', '.sql', '.tex', '.typ', '.properties', '.gradle', '.gitignore',
+]);
+const MOBILE_EDITOR_MAX_BYTES = 1024 * 1024;
+function resolveMobileWorkspacePath(ws, relativePath) {
+    const root = path.resolve(ws.path);
+    const clean = String(relativePath || '').replace(/\\/g, '/').replace(/^\/+/, '');
+    const target = path.resolve(root, clean || '.');
+    if (target !== root && !target.startsWith(root + path.sep))
+        throw new Error('Path escapes workspace');
+    return { root, target, relative: path.relative(root, target).replace(/\\/g, '/') };
+}
+async function assertMobileRealPathContained(root, target) {
+    const realRoot = await fs.promises.realpath(root);
+    const realTarget = await fs.promises.realpath(target);
+    if (realTarget !== realRoot && !realTarget.startsWith(realRoot + path.sep))
+        throw new Error('Path escapes workspace through a symbolic link');
+}
+function mobileEditableFile(target) {
+    const base = path.basename(target).toLowerCase();
+    return MOBILE_EDITABLE_EXTENSIONS.has(path.extname(base)) || MOBILE_EDITABLE_EXTENSIONS.has(base);
+}
+function mobileRightSidebarState(current, ws, conversationId) {
+    const scoped = mobileScopedAgent(ws, conversationId);
+    return {
+        workspace: { id: ws.id, name: ws.name, path: ws.path, isInternal: ws.isInternal },
+        conversationId,
+        conversationPlan: scoped.getConversationPlan(conversationId),
+        linkedPlan: scoped.getLinkedPlan(conversationId),
+        subagents: scoped.subagents.listAll()
+            .filter(record => !record.conversationId || record.conversationId === conversationId)
+            .map(record => ({
+            id: record.id,
+            name: record.name,
+            displayName: record.displayName,
+            status: record.status,
+            model: record.model,
+            mode: record.agentMode,
+            inputMode: record.inputMode,
+            result: record.result,
+            error: record.error || '',
+            messageCount: record.messages.length,
+            messages: record.messages.slice(-40),
+        })),
+    };
+}
+function mobileWorkspaceConversationRows(current, ws) {
+    const activeConversationId = current.activeConversationIdForWorkspace(ws);
+    const isRuntimeWorkspace = !!current.workspace.current
+        && path.resolve(current.workspace.current.path) === path.resolve(ws.path);
+    const activeRuntimeStatus = current.status === 'working' ? 'running' : current.status;
+    return current.listWorkspaceConversationStates(ws).map(conversation => {
+        const scopedRuntime = mobileScopedRuntimes.get(mobileRuntimeKey(String(ws.id || ''), conversation.id));
+        const scopedStatus = scopedRuntime?.agent.status === 'working' ? 'running' : scopedRuntime?.agent.status || '';
+        const runtimeStatus = scopedRuntime
+            ? scopedStatus
+            : isRuntimeWorkspace && conversation.id === current.activeConversationId && activeRuntimeStatus !== 'idle'
+                ? activeRuntimeStatus
+                : '';
+        return {
+            ...conversation,
+            active: conversation.id === activeConversationId || !!scopedRuntime,
+            runtimeStatus,
+            running: ['running', 'stopping', 'force_restarting'].includes(runtimeStatus),
+        };
+    });
+}
+function mobileScopedAgent(ws, conversationId) {
+    const scoped = new agent_1.Agent(appRoot, {
+        agentOnly: true,
+        workspaceRegistryMode: 'detached',
+        readOnlyConfig: true,
+        conversationId,
+    });
+    scoped.workspace.current = { ...ws };
+    scoped.config.loadWorkspaceConfig(ws.path);
+    scoped.setConversationFromStorage(conversationId);
+    return scoped;
+}
+function mobileConversationRuntimeBusy(current, ws, conversationId) {
+    const scoped = mobileScopedRuntimes.get(mobileRuntimeKey(String(ws.id || ''), conversationId));
+    if (scoped && scoped.agent.status !== 'idle')
+        return true;
+    const currentWs = current.workspace.current;
+    return !!currentWs
+        && path.resolve(currentWs.path) === path.resolve(ws.path)
+        && current.activeConversationId === conversationId
+        && current.status !== 'idle';
+}
+function handleMobileEvents(req, res) {
+    if (agent && !agent.config.getBool('remote', 'touch_enabled')) {
+        mobileJson(res, { error: 'Remote touch disabled' }, 403);
+        return;
+    }
+    if (!mobileAuthorized(req)) {
+        mobileJson(res, { error: 'Unauthorized' }, 401);
+        return;
+    }
+    if (!agent) {
+        mobileJson(res, { error: 'Agent not initialized' }, 500);
+        return;
+    }
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+    });
+    res.write('retry: 3000\n\n');
+    const subscriber = (event) => {
+        try {
+            res.write(`event: work\ndata: ${JSON.stringify(event)}\n\n`);
+        }
+        catch {
+            // socket is gone; the close handler will clean up
+        }
+    };
+    mobileWorkEventSubscribers.add(subscriber);
+    const heartbeat = setInterval(() => {
+        try {
+            res.write(': ping\n\n');
+        }
+        catch { }
+    }, 15000);
+    res.on('close', () => {
+        clearInterval(heartbeat);
+        mobileWorkEventSubscribers.delete(subscriber);
+    });
+}
 function resolveAppPath(root, targetPath) {
     if (!targetPath)
         return root;
@@ -214,6 +392,16 @@ function jsonResponse(res, data, code = 200) {
 async function handleApi(req, res, body) {
     const url = new URL(req.url || '/', `http://localhost:${PORT}`);
     const pathname = url.pathname;
+    if (pathname.startsWith('/api/mobile/')) {
+        if (agent && !agent.config.getBool('remote', 'touch_enabled')) {
+            mobileJson(res, { error: 'Remote touch disabled' }, 403);
+            return;
+        }
+        if (!mobileAuthorized(req)) {
+            mobileJson(res, { error: 'Unauthorized' }, 401);
+            return;
+        }
+    }
     if (!agent) {
         jsonResponse(res, { error: 'Agent not initialized' }, 500);
         return;
@@ -603,15 +791,520 @@ async function handleApi(req, res, body) {
                 jsonResponse(res, { content: agent.readArchive(aName2) });
                 return;
             }
+            case '/api/mobile/pair-confirm': {
+                let pairingId = url.searchParams.get('pairingId') || '';
+                if (!pairingId) {
+                    try {
+                        pairingId = String(JSON.parse(body || '{}').pairingId || '');
+                    }
+                    catch { }
+                }
+                const result = (0, mobilePairing_1.confirmPairing)(appRoot, pairingId, mobileToken);
+                mobileJson(res, result.ok
+                    ? { ok: true, status: result.status }
+                    : { ok: false, error: result.error, status: result.status }, result.ok ? 200 : 401);
+                return;
+            }
+            case '/api/mobile/pair-status': {
+                mobileJson(res, { ok: true, status: (0, mobilePairing_1.pairingStatus)(appRoot) });
+                return;
+            }
+            case '/api/mobile/hello': {
+                mobileJson(res, {
+                    ok: true,
+                    version: (0, installUpdate_1.currentAppVersion)(),
+                    hostname: os.hostname(),
+                    platform: process.platform,
+                    tailscaleIpv4: (0, mobilePairing_1.tailscaleIpv4)(),
+                    lanIpv4: (0, mobilePairing_1.lanIpv4)(),
+                    workspace: agent.workspace.current ? {
+                        id: agent.workspace.current.id,
+                        name: agent.workspace.current.name,
+                        path: agent.workspace.current.path,
+                    } : null,
+                    conversationCount: agent.listConversationStates().length,
+                    activeConversationId: agent.activeConversationId,
+                });
+                return;
+            }
+            case '/api/mobile/state': {
+                const active = agent.getConversationSnapshot(agent.activeConversationId, { window: 200 });
+                // 完整对话信息：workRuns 用持久化记录透出（含被中断的构建，不依赖运行时内存）
+                const persistedRuns = agent.getPersistedConversationWorkRuns(agent.activeConversationId);
+                if (persistedRuns.length)
+                    active.workRuns = persistedRuns;
+                mobileJson(res, {
+                    mode: agent.mode,
+                    model: agent.modelSelectionValue(),
+                    modelLabel: agent.modelLabel(),
+                    status: agent.status,
+                    activeConversationId: agent.activeConversationId,
+                    conversations: agent.listConversationStates(),
+                    workspaces: { internal: agent.workspace.internal, external: agent.workspace.external, current: agent.workspace.current },
+                    pendingOptions: agent.pendingOptions,
+                    contextWindow: agent.contextWindow(),
+                    chatMessages: active.chatMessages,
+                    totalMessages: active.totalMessages,
+                    conversationLocked: agent.isConversationLocked(),
+                    // workRuns 透出：完整 Build Block 记录（含 interrupted/force_interrupted），供移动端渲染被中断的对话
+                    workRuns: active.workRuns,
+                    // goal bar / flow bar：目标状态与当前 Flow 选择
+                    goal: active.goal,
+                    flowSelection: active.flowSelection,
+                });
+                return;
+            }
+            case '/api/mobile/conversations': {
+                mobileJson(res, agent.listConversationStates());
+                return;
+            }
+            case '/api/mobile/conversation': {
+                const workspaceId = url.searchParams.get('workspaceId') || '';
+                const windowParam = url.searchParams.get('window');
+                const beforeParam = url.searchParams.get('before');
+                const windowSize = windowParam ? Math.max(1, Math.min(500, Number(windowParam) || 200)) : 200;
+                const before = beforeParam ? Math.max(0, Number(beforeParam) || 0) : undefined;
+                const current = agent;
+                const ws = workspaceId ? resolveMobileWorkspace(current, workspaceId) : null;
+                if (workspaceId && !ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const conversationId = url.searchParams.get('conversationId')
+                    || (ws ? current.activeConversationIdForWorkspace(ws) : current.activeConversationId);
+                if (ws && !current.hasConversationInWorkspace(String(conversationId), ws)) {
+                    mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                const snapshot = current.getConversationSnapshot(String(conversationId), { window: windowSize, before, workspace: ws });
+                // 完整对话信息：workRuns 统一用持久化记录透出（含被中断的构建）
+                const persistedRuns = current.getPersistedConversationWorkRuns(String(conversationId), ws || undefined);
+                if (persistedRuns.length)
+                    snapshot.workRuns = persistedRuns;
+                mobileJson(res, snapshot);
+                return;
+            }
+            case '/api/mobile/workspaces': {
+                mobileJson(res, { internal: agent.workspace.internal, external: agent.workspace.external, current: agent.workspace.current });
+                return;
+            }
+            case '/api/mobile/workspace-conversations': {
+                const workspaceId = url.searchParams.get('workspaceId') || '';
+                const current = agent;
+                const ws = resolveMobileWorkspace(current, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const conversations = mobileWorkspaceConversationRows(current, ws);
+                mobileJson(res, { workspace: { id: ws.id, name: ws.name, path: ws.path, isInternal: ws.isInternal }, conversations });
+                return;
+            }
+            case '/api/mobile/right-sidebar-state': {
+                const workspaceId = url.searchParams.get('workspaceId') || '';
+                const conversationId = url.searchParams.get('conversationId') || '';
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                if (!conversationId || !agent.hasConversationInWorkspace(conversationId, ws)) {
+                    mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                mobileJson(res, mobileRightSidebarState(agent, ws, conversationId));
+                return;
+            }
+            case '/api/mobile/workspace-files': {
+                const workspaceId = url.searchParams.get('workspaceId') || '';
+                const relativePath = url.searchParams.get('path') || '';
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const resolved = resolveMobileWorkspacePath(ws, relativePath);
+                await assertMobileRealPathContained(resolved.root, resolved.target);
+                const stat = await fs.promises.stat(resolved.target);
+                if (!stat.isDirectory()) {
+                    mobileJson(res, { error: 'Path is not a directory' }, 400);
+                    return;
+                }
+                const entries = await fs.promises.readdir(resolved.target, { withFileTypes: true });
+                const rows = entries
+                    .filter(entry => entry.name !== '.git' && entry.name !== 'node_modules')
+                    .map(entry => ({
+                    name: entry.name,
+                    path: path.posix.join(resolved.relative, entry.name).replace(/^\.\//, ''),
+                    directory: entry.isDirectory(),
+                }))
+                    .sort((a, b) => Number(b.directory) - Number(a.directory) || a.name.localeCompare(b.name));
+                mobileJson(res, { workspaceId, path: resolved.relative, entries: rows });
+                return;
+            }
+            case '/api/mobile/workspace-file': {
+                if (req.method === 'GET') {
+                    const workspaceId = url.searchParams.get('workspaceId') || '';
+                    const relativePath = url.searchParams.get('path') || '';
+                    const ws = resolveMobileWorkspace(agent, workspaceId);
+                    if (!ws) {
+                        mobileJson(res, { error: 'Unknown workspace' }, 404);
+                        return;
+                    }
+                    const resolved = resolveMobileWorkspacePath(ws, relativePath);
+                    await assertMobileRealPathContained(resolved.root, resolved.target);
+                    const stat = await fs.promises.stat(resolved.target);
+                    if (!stat.isFile() || stat.size > MOBILE_EDITOR_MAX_BYTES || !mobileEditableFile(resolved.target)) {
+                        mobileJson(res, { error: 'File is not an editable text file' }, 415);
+                        return;
+                    }
+                    const content = (await fs.promises.readFile(resolved.target, 'utf-8')).replace(/^\uFEFF/, '');
+                    mobileJson(res, { workspaceId, path: resolved.relative, content, size: stat.size });
+                    return;
+                }
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const relativePath = String(params.path || '');
+                const content = String(params.content ?? '');
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                if (Buffer.byteLength(content, 'utf-8') > MOBILE_EDITOR_MAX_BYTES) {
+                    mobileJson(res, { error: 'File exceeds mobile editor size limit' }, 413);
+                    return;
+                }
+                const resolved = resolveMobileWorkspacePath(ws, relativePath);
+                await assertMobileRealPathContained(resolved.root, resolved.target);
+                if (!mobileEditableFile(resolved.target)) {
+                    mobileJson(res, { error: 'File type is not editable' }, 415);
+                    return;
+                }
+                const stat = await fs.promises.stat(resolved.target);
+                if (!stat.isFile()) {
+                    mobileJson(res, { error: 'Path is not a file' }, 400);
+                    return;
+                }
+                await fs.promises.writeFile(resolved.target, content, 'utf-8');
+                mobileJson(res, { ok: true, workspaceId, path: resolved.relative, size: Buffer.byteLength(content, 'utf-8') });
+                return;
+            }
+            case '/api/mobile/conversation-plan-update': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                if (!conversationId || !agent.hasConversationInWorkspace(conversationId, ws)) {
+                    mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                const scoped = mobileScopedAgent(ws, conversationId);
+                const plan = scoped.updateConversationPlan({ items: Array.isArray(params.items) ? params.items : [] }, conversationId);
+                mobileJson(res, { ok: true, conversationPlan: plan });
+                return;
+            }
+            case '/api/mobile/conversation-create': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                if (!workspaceId) {
+                    mobileJson(res, { error: 'No workspaceId' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const created = agent.createConversationInWorkspace(ws, String(params.title || ''));
+                mobileJson(res, {
+                    ok: true,
+                    workspace: { id: ws.id, name: ws.name, path: ws.path, isInternal: ws.isInternal },
+                    conversation: created,
+                    activeConversationId: created.id,
+                    conversations: mobileWorkspaceConversationRows(agent, ws),
+                });
+                return;
+            }
+            case '/api/mobile/conversation-rename': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                const title = String(params.title || '');
+                if (!workspaceId || !conversationId || !title.trim()) {
+                    mobileJson(res, { error: 'workspaceId, conversationId, and title are required' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const ok = agent.renameConversation(conversationId, title, ws);
+                if (!ok) {
+                    mobileJson(res, { ok: false, error: 'Conversation rename failed' }, 404);
+                    return;
+                }
+                mobileJson(res, { ok: true, conversations: mobileWorkspaceConversationRows(agent, ws) });
+                return;
+            }
+            case '/api/mobile/conversation-pin': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                if (!workspaceId || !conversationId) {
+                    mobileJson(res, { error: 'workspaceId and conversationId are required' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const pinned = params.pinned === true;
+                const ok = agent.setConversationPinned(conversationId, pinned, ws);
+                if (!ok) {
+                    mobileJson(res, { ok: false, error: 'Conversation pin update failed' }, 404);
+                    return;
+                }
+                mobileJson(res, { ok: true, pinned, conversations: mobileWorkspaceConversationRows(agent, ws) });
+                return;
+            }
+            case '/api/mobile/conversation-reorder': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationIds = Array.isArray(params.conversationIds)
+                    ? params.conversationIds.map((id) => String(id || ''))
+                    : [];
+                if (!workspaceId || conversationIds.length < 2 || conversationIds.some((id) => !id)) {
+                    mobileJson(res, { error: 'workspaceId and at least two conversationIds are required' }, 400);
+                    return;
+                }
+                if (new Set(conversationIds).size !== conversationIds.length) {
+                    mobileJson(res, { error: 'conversationIds must be unique' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                const current = agent;
+                if (conversationIds.some((id) => !current.hasConversationInWorkspace(id, ws))) {
+                    mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                const listedById = new Map(current.listWorkspaceConversationStates(ws).map(item => [item.id, item]));
+                if (new Set(conversationIds.map((id) => !!listedById.get(id)?.pinned)).size !== 1) {
+                    mobileJson(res, { error: 'Conversations must remain within one pinned group' }, 409);
+                    return;
+                }
+                const ok = current.reorderWorkspaceConversationGroup(conversationIds, ws);
+                if (!ok) {
+                    mobileJson(res, { ok: false, error: 'Conversation reorder failed' }, 409);
+                    return;
+                }
+                mobileJson(res, { ok: true, conversations: mobileWorkspaceConversationRows(current, ws) });
+                return;
+            }
+            case '/api/mobile/send': {
+                const params = JSON.parse(body || '{}');
+                const message = String(params.message || '');
+                if (!message) {
+                    mobileJson(res, { error: 'No message' }, 400);
+                    return;
+                }
+                const workspaceId = String(params.workspaceId || '');
+                let requestAgent = agent;
+                let requestWorkspace = agent.workspace.current;
+                let resolvedWorkspace = null;
+                if (workspaceId) {
+                    const ws = resolveMobileWorkspace(agent, workspaceId);
+                    if (!ws) {
+                        mobileJson(res, { error: 'Unknown workspace' }, 404);
+                        return;
+                    }
+                    resolvedWorkspace = ws;
+                    requestWorkspace = ws;
+                }
+                const conversationId = String(params.conversationId
+                    || (resolvedWorkspace ? agent.activeConversationIdForWorkspace(resolvedWorkspace) : agent.activeConversationId));
+                if (resolvedWorkspace) {
+                    const ws = resolvedWorkspace;
+                    if (!agent.hasConversationInWorkspace(conversationId, ws)) {
+                        mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                        return;
+                    }
+                    const currentWs = agent.workspace.current;
+                    if (!currentWs || path.resolve(currentWs.path) !== path.resolve(ws.path)) {
+                        requestAgent = mobileScopedAgent(ws, conversationId);
+                    }
+                }
+                if (requestAgent === agent && params.conversationId)
+                    requestAgent.setConversation(conversationId);
+                let scopedRuntimeKey = '';
+                let scopedRuntime = null;
+                let unsubscribeScoped = null;
+                if (requestAgent !== agent && requestWorkspace) {
+                    scopedRuntimeKey = mobileRuntimeKey(String(requestWorkspace.id || ''), conversationId);
+                    unsubscribeScoped = requestAgent.subscribeWorkEvents(event => publishMobileWorkEvent({
+                        ...event,
+                        workspaceId: String(requestWorkspace?.id || ''),
+                        conversationId,
+                    }));
+                    scopedRuntime = {
+                        agent: requestAgent,
+                        workspaceId: String(requestWorkspace.id || ''),
+                        conversationId,
+                        unsubscribe: unsubscribeScoped,
+                    };
+                    mobileScopedRuntimes.set(scopedRuntimeKey, scopedRuntime);
+                }
+                let tokens;
+                try {
+                    tokens = await requestAgent.process(message);
+                }
+                finally {
+                    if (scopedRuntimeKey && mobileScopedRuntimes.get(scopedRuntimeKey) === scopedRuntime) {
+                        mobileScopedRuntimes.delete(scopedRuntimeKey);
+                    }
+                    if (unsubscribeScoped)
+                        unsubscribeScoped();
+                }
+                const snapshot = requestAgent.getConversationSnapshot(conversationId, {
+                    window: 200,
+                    workspace: requestWorkspace,
+                });
+                mobileJson(res, {
+                    ok: true,
+                    conversationId,
+                    response: tokens.map(token => token.text).join(''),
+                    tokens: tokens.map(token => ({ type: token.type, text: token.text })),
+                    options: requestAgent.pendingOptions,
+                    status: requestAgent.status,
+                    conversations: requestWorkspace
+                        ? mobileWorkspaceConversationRows(requestAgent, requestWorkspace)
+                        : requestAgent.listConversationStates(),
+                    chatMessages: snapshot.chatMessages,
+                    totalMessages: snapshot.totalMessages,
+                });
+                return;
+            }
+            case '/api/mobile/conversation-branch-inspect':
+            case '/api/mobile/conversation-branch-activate':
+            case '/api/mobile/conversation-branch-create': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                if (!workspaceId || !conversationId) {
+                    mobileJson(res, { error: 'workspaceId and conversationId are required' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                if (!agent.hasConversationInWorkspace(conversationId, ws)) {
+                    mobileJson(res, { error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                const scoped = mobileScopedAgent(ws, conversationId);
+                if (pathname === '/api/mobile/conversation-branch-inspect') {
+                    const branchId = String(params.branchId || '');
+                    if (!branchId) {
+                        mobileJson(res, { error: 'branchId is required' }, 400);
+                        return;
+                    }
+                    mobileJson(res, scoped.inspectConversationBranch(conversationId, branchId, String(params.branchGroupId || '')));
+                    return;
+                }
+                if (mobileConversationRuntimeBusy(agent, ws, conversationId)) {
+                    mobileJson(res, { error: 'Conversation is running' }, 423);
+                    return;
+                }
+                if (pathname === '/api/mobile/conversation-branch-activate') {
+                    const branchId = String(params.branchId || '');
+                    if (!branchId) {
+                        mobileJson(res, { error: 'branchId is required' }, 400);
+                        return;
+                    }
+                    mobileJson(res, scoped.switchConversationBranch(conversationId, branchId, String(params.branchGroupId || '')));
+                    return;
+                }
+                const messageIndex = Math.floor(Number(params.messageIndex));
+                const editedText = String(params.editedText || '').trim();
+                if (!Number.isFinite(messageIndex) || messageIndex < 0 || !editedText) {
+                    mobileJson(res, { error: 'messageIndex and editedText are required' }, 400);
+                    return;
+                }
+                const branchNodePath = Array.isArray(params.branchNodePath)
+                    ? params.branchNodePath.map((id) => String(id || '')).filter(Boolean)
+                    : [];
+                const snapshot = scoped.branchConversation(conversationId, messageIndex, editedText, {
+                    messageId: String(params.messageId || '') || undefined,
+                    guideId: String(params.guideId || '') || undefined,
+                    clientMessageId: String(params.clientMessageId || '') || undefined,
+                    runId: String(params.runId || '') || undefined,
+                    branchNodePath,
+                });
+                mobileJson(res, snapshot);
+                return;
+            }
+            case '/api/mobile/conversation-archive': {
+                const params = JSON.parse(body || '{}');
+                const conversationId = String(params.conversationId || '');
+                const workspaceId = String(params.workspaceId || '');
+                if (!workspaceId || !conversationId) {
+                    mobileJson(res, { error: 'workspaceId and conversationId are required' }, 400);
+                    return;
+                }
+                const ws = resolveMobileWorkspace(agent, workspaceId);
+                if (!ws) {
+                    mobileJson(res, { error: 'Unknown workspace' }, 404);
+                    return;
+                }
+                if (!agent.hasConversationInWorkspace(conversationId, ws)) {
+                    mobileJson(res, { ok: false, error: 'Conversation not found in workspace' }, 404);
+                    return;
+                }
+                // 运行中拒绝：与移动端 running 判定一致（activeConversationId + agent.status 非 idle）
+                if (mobileConversationRuntimeBusy(agent, ws, conversationId)) {
+                    mobileJson(res, { ok: false, error: 'Conversation is running' }, 423);
+                    return;
+                }
+                const filename = await agent.archiveConversationAsync(conversationId, ws);
+                if (!filename) {
+                    mobileJson(res, { ok: false, error: 'Conversation archive could not be written.' }, 500);
+                    return;
+                }
+                mobileJson(res, {
+                    ok: true,
+                    fileName: filename,
+                    conversationId,
+                    activeConversationId: agent.activeConversationIdForWorkspace(ws),
+                    conversations: mobileWorkspaceConversationRows(agent, ws),
+                });
+                return;
+            }
             default:
                 jsonResponse(res, { error: 'Unknown API' }, 404);
         }
     }
     catch (e) {
-        jsonResponse(res, { error: e.message }, 500);
+        if (pathname.startsWith('/api/mobile/'))
+            mobileJson(res, { error: e.message }, 500);
+        else
+            jsonResponse(res, { error: e.message }, 500);
     }
 }
 function startServer(root) {
+    mobileToken = (0, mobilePairing_1.ensureMobileToken)(root);
+    appRoot = root;
     agent = new agent_1.Agent(root);
     workspaceFileRouter = new workspaceFileRouter_1.WorkspaceFileRouter(() => path.resolve(agent?.workspace.current?.path || root));
     automation = new automation_1.AutomationManager(agent.config, async (prompt, model, item) => {
@@ -640,16 +1333,25 @@ function startServer(root) {
             agent.setConversationFromStorage(previousConversation);
         }
     });
+    agent.subscribeWorkEvents(publishMobileWorkEvent);
     agent.setAutomationManager(automation);
     automation.start();
     const uiDir = path.join(__dirname, 'ui');
     const server = http.createServer(async (req, res) => {
         if (req.method === 'OPTIONS') {
-            res.writeHead(204);
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            });
             res.end();
             return;
         }
         const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+        if (url.pathname === '/api/mobile/events') {
+            handleMobileEvents(req, res);
+            return;
+        }
         if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
             let body = '';
             req.on('data', chunk => body += chunk);
@@ -667,13 +1369,29 @@ function startServer(root) {
         const fullPath = path.join(uiDir, filePath);
         serveFile(res, fullPath);
     });
-    server.listen(PORT, '127.0.0.1', () => {
+    const bindHost = process.env.NEWMARK_BIND_HOST || '0.0.0.0';
+    const tailscale = (0, mobilePairing_1.tailscaleIpv4)();
+    const lan = (0, mobilePairing_1.lanIpv4)();
+    const accessHost = tailscale || lan || '<lan-or-tailscale-ip>';
+    const tokenPath = path.join(root, '.newmark-mobile-token');
+    server.listen(PORT, bindHost, () => {
         console.log(`\n  Newmark Agent v1.0 - Server Mode`);
+        console.log(`  Bind: ${bindHost}:${PORT}`);
         console.log(`  GUI: http://localhost:${PORT}`);
+        console.log(`  Tailscale IPv4: ${tailscale || 'not detected'}`);
+        console.log(`  LAN IPv4: ${lan || 'not detected'}`);
+        console.log(`  Mobile endpoint: http://${accessHost}:${PORT}/api/mobile/hello?token=<token>`);
+        console.log(`  Mobile token file: ${tokenPath}`);
+        console.log(`  Mobile events (SSE): http://${accessHost}:${PORT}/api/mobile/events?token=<token>`);
         console.log(`  Press Ctrl+C to stop\n`);
     });
 }
+let hostedServerStarted = false;
+/** 托管启动 server（GUI/TUI 内嵌调用；幂等防重入，进程常驻即服务常驻） */
 function runServer(root) {
+    if (hostedServerStarted)
+        return;
+    hostedServerStarted = true;
     startServer(root);
 }
 //# sourceMappingURL=server.js.map