newmark-agent 0.4.6 → 0.4.8

package/dist/server.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runServer = runServer;
+exports.setHostedServerAutomation = setHostedServerAutomation;
 const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -54,6 +55,28 @@ let automation = null;
 let workspaceFileRouter = null;
 let mobileToken = '';
 let appRoot = '';
+const mobileWorkEventSubscribers = new Set();
+const mobileScopedRuntimes = new Map();
+let hostedWorkEventSink = null;
+let unsubscribeHostedWorkEvents = null;
+let hostedConversationUiState;
+let hostedConversationUiAction;
+let hostedConversationPrompt;
+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 publishServerWorkEvent(event) {
+    publishMobileWorkEvent(event);
+    hostedWorkEventSink?.(event);
+}
 function mobileAuthorized(req) {
     if (!mobileToken)
         return false;
@@ -77,6 +100,103 @@ function mobileJson(res, data, code = 200) {
     });
     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);
@@ -97,23 +217,24 @@ function handleMobileEvents(req, res) {
         'Access-Control-Allow-Origin': '*',
     });
     res.write('retry: 3000\n\n');
-    const unsubscribe = agent.subscribeWorkEvents(event => {
+    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);
-    req.on('close', () => {
+    res.on('close', () => {
         clearInterval(heartbeat);
-        unsubscribe();
+        mobileWorkEventSubscribers.delete(subscriber);
     });
 }
 function resolveAppPath(root, targetPath) {
@@ -705,6 +826,7 @@ async function handleApi(req, res, body) {
                     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,
@@ -717,9 +839,17 @@ async function handleApi(req, res, body) {
             }
             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(),
+                    models: agent.allModelNames(),
+                    providers: (0, config_1.sanitizeProvidersForState)(agent.config.providers()),
+                    intelligence: agent.intelligence,
                     status: agent.status,
                     activeConversationId: agent.activeConversationId,
                     conversations: agent.listConversationStates(),
@@ -729,6 +859,11 @@ async function handleApi(req, res, body) {
                     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;
             }
@@ -737,12 +872,37 @@ async function handleApi(req, res, body) {
                 return;
             }
             case '/api/mobile/conversation': {
-                const conversationId = url.searchParams.get('conversationId') || agent.activeConversationId;
+                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 snapshot = agent.getConversationSnapshot(String(conversationId), { window: windowSize, before });
+                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;
+                }
+                // GUI conversations normally execute inside isolated runtime pools.
+                // Their durable target state can be newer than the hosted main Agent's
+                // foreground memory, so workspace-bound mobile reads must hydrate a
+                // fresh read-only target Agent from storage.
+                const snapshotAgent = ws ? mobileScopedAgent(ws, String(conversationId)) : current;
+                const snapshot = snapshotAgent.getConversationSnapshot(String(conversationId), {
+                    window: windowSize,
+                    before,
+                    workspace: ws || undefined,
+                });
+                // 完整对话信息：workRuns 统一用持久化记录透出（含被中断的构建）
+                const persistedRuns = snapshotAgent.getPersistedConversationWorkRuns(String(conversationId), ws || undefined);
+                if (persistedRuns.length)
+                    snapshot.workRuns = persistedRuns;
                 mobileJson(res, snapshot);
                 return;
             }
@@ -750,6 +910,305 @@ async function handleApi(req, res, body) {
                 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/conversation-ui-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;
+                }
+                if (hostedConversationUiState) {
+                    mobileJson(res, await hostedConversationUiState({ workspaceId, conversationId }));
+                    return;
+                }
+                const scoped = mobileScopedAgent(ws, conversationId);
+                const snapshot = scoped.getConversationSnapshot(conversationId, { workspace: ws, window: 1 });
+                mobileJson(res, {
+                    goal: snapshot.goal,
+                    flowSelection: snapshot.flowSelection,
+                    flow: null,
+                    queued: { steering: [], followUp: [] },
+                    runtime: null,
+                    mode: scoped.mode,
+                    status: scoped.status,
+                    inputMode: scoped.inputMode,
+                });
+                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/model': {
+                const next = String(JSON.parse(body || '{}').model || '');
+                if (!next) {
+                    mobileJson(res, { error: 'Model is required' }, 400);
+                    return;
+                }
+                agent.setModel(next);
+                mobileJson(res, {
+                    ok: true,
+                    model: agent.modelSelectionValue(),
+                    modelLabel: agent.modelLabel(),
+                });
+                return;
+            }
+            case '/api/mobile/intelligence': {
+                const tier = String(JSON.parse(body || '{}').tier || 'medium');
+                agent.setIntelligence(tier, true);
+                mobileJson(res, { ok: true, intelligence: agent.intelligence });
+                return;
+            }
+            case '/api/mobile/conversation-ui-action': {
+                const params = JSON.parse(body || '{}');
+                const workspaceId = String(params.workspaceId || '');
+                const conversationId = String(params.conversationId || '');
+                const action = String(params.action || '');
+                const allowed = new Set(['goal_update', 'goal_guide', 'conversation_guide', 'goal_toggle_pause', 'goal_clear', 'flow_pause', 'flow_resume', 'flow_guide', 'conversation_stop', 'input_mode', 'queue_enqueue', 'queue_update', 'queue_delete', 'queue_toggle_pause', 'queue_guide']);
+                if (!workspaceId || !conversationId || !allowed.has(action)) {
+                    mobileJson(res, { error: 'workspaceId, conversationId, and a valid action 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;
+                }
+                if (!hostedConversationUiAction) {
+                    mobileJson(res, { error: 'This action requires the GUI-hosted mobile server' }, 409);
+                    return;
+                }
+                mobileJson(res, await hostedConversationUiAction({ workspaceId, conversationId }, action, String(params.value || ''), params));
+                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 || '');
@@ -757,23 +1216,188 @@ async function handleApi(req, res, body) {
                     mobileJson(res, { error: 'No message' }, 400);
                     return;
                 }
-                if (params.conversationId)
-                    agent.setConversation(String(params.conversationId));
-                const tokens = await agent.process(message);
-                const snapshot = agent.getConversationSnapshot(agent.activeConversationId, { window: 200 });
+                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 (hostedConversationPrompt && resolvedWorkspace) {
+                    const result = await hostedConversationPrompt({ workspaceId, conversationId }, message, {
+                        requestedMode: String(params.requestedMode || ''),
+                        goalObjective: String(params.goalObjective || ''),
+                        inputMode: String(params.inputMode || ''),
+                    });
+                    mobileJson(res, { ok: true, conversationId, ...result });
+                    return;
+                }
+                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 => publishServerWorkEvent({
+                        ...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: agent.activeConversationId,
+                    conversationId,
                     response: tokens.map(token => token.text).join(''),
                     tokens: tokens.map(token => ({ type: token.type, text: token.text })),
-                    options: agent.pendingOptions,
-                    status: agent.status,
-                    conversations: agent.listConversationStates(),
+                    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);
         }
@@ -785,39 +1409,51 @@ async function handleApi(req, res, body) {
             jsonResponse(res, { error: e.message }, 500);
     }
 }
-function startServer(root) {
+function startServer(root, options = {}) {
     mobileToken = (0, mobilePairing_1.ensureMobileToken)(root);
     appRoot = root;
-    agent = new agent_1.Agent(root);
+    agent = options.agent || new agent_1.Agent(root);
+    hostedWorkEventSink = options.onWorkEvent || null;
+    hostedConversationUiState = options.conversationUiState;
+    hostedConversationUiAction = options.conversationUiAction;
+    hostedConversationPrompt = options.conversationPrompt;
+    unsubscribeHostedWorkEvents?.();
+    unsubscribeHostedWorkEvents = options.subscribeWorkEvents?.(publishMobileWorkEvent) || null;
     workspaceFileRouter = new workspaceFileRouter_1.WorkspaceFileRouter(() => path.resolve(agent?.workspace.current?.path || root));
-    automation = new automation_1.AutomationManager(agent.config, async (prompt, model, item) => {
-        if (!agent)
-            return '';
-        const previousModel = agent.model;
-        const previousWorkspace = agent.workspace.current?.id || agent.workspace.current?.path || '';
-        const previousConversation = agent.activeConversationId;
-        agent.selectWorkspaceFromStorage(item.workspaceId);
-        const conversationId = item.conversationMode === 'existing'
-            ? item.conversationId
-            : `automation-${item.id}-${Date.now().toString(36)}`;
-        agent.setConversationFromStorage(conversationId);
-        automation?.update(item.id, { lastConversationId: conversationId });
-        if (model)
-            agent.setModel(model);
-        try {
-            const tokens = await agent.process(prompt);
-            return tokens.map(t => t.text).join('');
-        }
-        finally {
+    automation = options.automation || null;
+    if (!automation && !options.agent)
+        automation = new automation_1.AutomationManager(agent.config, async (prompt, model, item) => {
+            if (!agent)
+                return '';
+            const previousModel = agent.model;
+            const previousWorkspace = agent.workspace.current?.id || agent.workspace.current?.path || '';
+            const previousConversation = agent.activeConversationId;
+            agent.selectWorkspaceFromStorage(item.workspaceId);
+            const conversationId = item.conversationMode === 'existing'
+                ? item.conversationId
+                : `automation-${item.id}-${Date.now().toString(36)}`;
+            agent.setConversationFromStorage(conversationId);
+            automation?.update(item.id, { lastConversationId: conversationId });
             if (model)
-                agent.setModel(previousModel);
-            if (previousWorkspace)
-                agent.selectWorkspaceFromStorage(previousWorkspace);
-            agent.setConversationFromStorage(previousConversation);
-        }
-    });
-    agent.setAutomationManager(automation);
-    automation.start();
+                agent.setModel(model);
+            try {
+                const tokens = await agent.process(prompt);
+                return tokens.map(t => t.text).join('');
+            }
+            finally {
+                if (model)
+                    agent.setModel(previousModel);
+                if (previousWorkspace)
+                    agent.selectWorkspaceFromStorage(previousWorkspace);
+                agent.setConversationFromStorage(previousConversation);
+            }
+        });
+    agent.subscribeWorkEvents(publishServerWorkEvent);
+    if (automation) {
+        agent.setAutomationManager(automation);
+        if (!options.automation)
+            automation.start();
+    }
     const uiDir = path.join(__dirname, 'ui');
     const server = http.createServer(async (req, res) => {
         if (req.method === 'OPTIONS') {
@@ -853,19 +1489,31 @@ function startServer(root) {
     });
     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 (install/start Tailscale)'}`);
-        console.log(`  Mobile endpoint: http://${tailscale || '<tailscale-ip>'}:${PORT}/api/mobile/hello?token=<token>`);
+        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://${tailscale || '<tailscale-ip>'}:${PORT}/api/mobile/events?token=<token>`);
+        console.log(`  Mobile events (SSE): http://${accessHost}:${PORT}/api/mobile/events?token=<token>`);
         console.log(`  Press Ctrl+C to stop\n`);
     });
 }
-function runServer(root) {
-    startServer(root);
+let hostedServerStarted = false;
+/** 托管启动 server（GUI/TUI 内嵌调用；幂等防重入，进程常驻即服务常驻） */
+function runServer(root, options = {}) {
+    if (hostedServerStarted)
+        return;
+    hostedServerStarted = true;
+    startServer(root, options);
+}
+/** Attach the GUI-owned automation manager after deferred startup. */
+function setHostedServerAutomation(manager) {
+    automation = manager;
 }
 //# sourceMappingURL=server.js.map