newmark-agent 0.4.5 → 0.4.6

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,76 @@ 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 = '';
+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 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 unsubscribe = agent.subscribeWorkEvents(event => {
+        try {
+            res.write(`event: work\ndata: ${JSON.stringify(event)}\n\n`);
+        }
+        catch {
+            // socket is gone; the close handler will clean up
+        }
+    });
+    const heartbeat = setInterval(() => {
+        try {
+            res.write(': ping\n\n');
+        }
+        catch { }
+    }, 15000);
+    req.on('close', () => {
+        clearInterval(heartbeat);
+        unsubscribe();
+    });
+}
 function resolveAppPath(root, targetPath) {
     if (!targetPath)
         return root;
@@ -214,6 +281,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 +680,114 @@ 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)(),
+                    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 });
+                mobileJson(res, {
+                    mode: agent.mode,
+                    model: agent.modelSelectionValue(),
+                    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(),
+                });
+                return;
+            }
+            case '/api/mobile/conversations': {
+                mobileJson(res, agent.listConversationStates());
+                return;
+            }
+            case '/api/mobile/conversation': {
+                const conversationId = url.searchParams.get('conversationId') || agent.activeConversationId;
+                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 });
+                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/send': {
+                const params = JSON.parse(body || '{}');
+                const message = String(params.message || '');
+                if (!message) {
+                    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 });
+                mobileJson(res, {
+                    ok: true,
+                    conversationId: agent.activeConversationId,
+                    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(),
+                    chatMessages: snapshot.chatMessages,
+                    totalMessages: snapshot.totalMessages,
+                });
+                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) => {
@@ -645,11 +821,19 @@ function startServer(root) {
     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,9 +851,17 @@ 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 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(`  Mobile token file: ${tokenPath}`);
+        console.log(`  Mobile events (SSE): http://${tailscale || '<tailscale-ip>'}:${PORT}/api/mobile/events?token=<token>`);
         console.log(`  Press Ctrl+C to stop\n`);
     });
 }

package/dist/tui/src/adapters/core-runtime-adapter.js

@@ -154,6 +154,7 @@ function createCoreRuntimeAdapter(options = {}) {
   const { AutomationManager } = require(path.join(desktopDist, "core", "automation.js"));
   const { FlowEngine } = require(path.join(desktopDist, "core", "flow.js"));
   const installUpdate = require(path.join(desktopDist, "core", "installUpdate.js"));
+  const mobilePairing = require(path.join(desktopDist, "core", "mobilePairing.js"));
   const root = path.resolve(options.root || path.join(os.homedir(), ".Newmark"));
   const workspacePath = safeWorkspacePath(root, options.workspacePath || process.cwd());
   ensureRuntimeRoot(root, configModule);
@@ -211,7 +212,8 @@ function createCoreRuntimeAdapter(options = {}) {
     defaultTerminalShell: agent.config.getStr("terminal", "default_shell") || (process.platform === "win32" ? "powershell" : "bash"),
     status: agent.status,
     connected: true,
-    runtimeRoot: root
+    runtimeRoot: root,
+    remoteTouchEnabled: agent.config.getBool('remote', 'touch_enabled')
   });
 
   const snapshotFor = (requested = currentTarget()) => {
@@ -473,6 +475,20 @@ function createCoreRuntimeAdapter(options = {}) {
     updateVersion() {
       return { version: installUpdate.currentAppVersion(), root };
     },
+    async pairingQr() {
+      const qr = await mobilePairing.pairingQrAscii(root);
+      return {
+        ascii: qr.ascii,
+        url: qr.session.url,
+        pairingId: qr.session.pairingId,
+        expiresAt: qr.session.expiresAt,
+        tokenFile: mobilePairing.pairingTokenPath(root),
+        tailscaleIpv4: mobilePairing.tailscaleIpv4(),
+      };
+    },
+    pairingStatus() {
+      return mobilePairing.pairingStatus(root);
+    },
     updateCheckGithub(input = {}) {
       return installUpdate.checkGitHubUpdate(input.repo, input.tag, input.asset, input.token);
     },

package/dist/tui/src/app.js

@@ -93,6 +93,46 @@ function executeAction(state, action) {
     const appearance = applyThemeAppearance(state, state.theme === "dark" ? "Light" : "Dark");
     state.adapter.saveConfig(appearance);
     state.notice = `${state.theme === "dark" ? "Dark" : "Light"} terminal theme`;
+  } else if (action === "pair-mobile") {
+    state.overlay = "pair";
+    state.pairingQrLines = ["Loading pairing QR…"];
+    state.pairingUrl = "";
+    state.pairingTokenFile = "";
+    if (typeof state.requestPaint === "function") state.requestPaint();
+    if (typeof state.adapter.pairingQr !== "function") {
+      state.pairingQrLines = ["Pairing QR is unavailable in this adapter."];
+      if (typeof state.requestPaint === "function") state.requestPaint();
+      return;
+    }
+    Promise.resolve(state.adapter.pairingQr())
+      .then((pairing) => {
+        state.pairingQrLines = String(pairing?.ascii || "").split(/\r?\n/);
+        state.pairingUrl = String(pairing?.url || "");
+        state.pairingTokenFile = String(pairing?.tokenFile || "");
+        if (typeof state.requestPaint === "function") state.requestPaint();
+        if (typeof state.adapter.pairingStatus === "function") {
+          if (state._pairingPoll) clearInterval(state._pairingPoll);
+          state._pairingPoll = setInterval(() => {
+            const status = state.adapter.pairingStatus();
+            if (!status) return;
+            if (status.confirmed) {
+              clearInterval(state._pairingPoll);
+              state.overlay = null;
+              state.notice = "Mobile device connected";
+              if (typeof state.requestPaint === "function") state.requestPaint();
+            } else if (status.expired || !status.active) {
+              clearInterval(state._pairingPoll);
+              state.overlay = null;
+              state.notice = "Pairing window expired";
+              if (typeof state.requestPaint === "function") state.requestPaint();
+            }
+          }, 1000);
+        }
+      })
+      .catch((error) => {
+        state.pairingQrLines = [`Pairing failed: ${error?.message || error}`];
+        if (typeof state.requestPaint === "function") state.requestPaint();
+      });
   } else if (action === "help") {
     state.overlay = "help";
   }
@@ -166,6 +206,7 @@ function start(options = {}) {
     return;
   }
   const state = createState({ adapter });
+  state.requestPaint = () => paint();
   let timer = null;
   let animationTimer = null;
   let closing = false;

package/dist/tui/src/data.js

@@ -315,6 +315,7 @@ const commands = [
   { label: "Open Automations", hint: "", action: "view:automation" },
   { label: "Open WorkFlow", hint: "", action: "view:workflow" },
   { label: "Open Settings", hint: "", action: "view:settings" },
+  { label: "Show mobile pairing QR", hint: "", action: "pair-mobile" },
   { label: "New conversation", hint: "N", action: "new-chat" },
   { label: "Toggle theme", hint: "T", action: "theme" },
   { label: "Keyboard shortcuts", hint: "?", action: "help" }

package/dist/tui/src/render.js

@@ -1154,6 +1154,17 @@ function overlayLines(state, width, p) {
       `${p.cyan}Press Esc or ? to close${p.reset}`
     ], Math.min(78, width - 4), p, "Keyboard shortcuts");
   }
+  if (state.overlay === "pair") {
+    const qrLines = Array.isArray(state.pairingQrLines) ? state.pairingQrLines : [];
+    const rows = [
+      ...qrLines,
+      "",
+      ...(state.pairingUrl ? [`${p.muted}${state.pairingUrl}${p.reset}`] : []),
+      ...(state.pairingTokenFile ? [`${p.muted}Token: ${state.pairingTokenFile}${p.reset}`] : []),
+      `${p.cyan}Scan with the Newmark mobile app · Esc close${p.reset}`
+    ];
+    return card(rows, Math.min(88, width - 4), p, "Pair mobile device");
+  }
   if (state.overlay === "palette") {
     const commands = filteredCommands(state);
     const paletteViewport = Math.min(7, Math.max(1, commands.length));

package/dist/tui/src/settings-schema.js

@@ -23,7 +23,9 @@ function settingsRows(state, tab = state.settingsTab) {
     { key: "dialogStyle", label: "Conversation style", value: s.general.dialogStyle, choices: ["Formal", "Friendly"], save: ["config", "dialogStyle"] },
     { key: "feedbackLevel", label: "Option feedback", value: s.general.feedbackLevel, choices: ["Default", "Ask more", "Ask less", "Autonomous"], save: ["config", "feedbackLevel"] },
     { key: "closeBehavior", label: "Close behavior", value: s.general.closeBehavior, choices: ["Close app", "Minimize to tray"], save: ["setting", "general", "close_behavior"] },
-    { key: "expandTools", label: "Expand tool usage", value: s.general.expandTools, choices: [true, false], save: ["setting", "general", "expand_tools"] }
+    { key: "expandTools", label: "Expand tool usage", value: s.general.expandTools, choices: [true, false], save: ["setting", "general", "expand_tools"] },
+    { key: "remoteTouch", label: "Remote behavior · Mobile remote-touch", value: s.general.remoteTouch, choices: [true, false], save: ["setting", "remote", "touch_enabled"] },
+    { key: "remotePair", label: "Remote behavior · Start connection", value: "Open QR", choices: [], action: "pair-mobile" }
   ];
   if (tab === "personalization") return [
     { key: "theme", label: "Theme", value: s.personalization.theme, choices: ["Dark", "Light", "System"], save: ["config", "theme"] },

package/dist/tui/src/state.js

@@ -253,7 +253,8 @@ function createState(options = {}) {
         dialogStyle: snapshot.dialogStyle === "friendly" ? "Friendly" : "Formal",
         feedbackLevel: { ask_more: "Ask more", ask_less: "Ask less", fully_autonomous: "Autonomous" }[snapshot.feedback] || "Default",
         closeBehavior: snapshot.closeBehavior === "minimize" ? "Minimize to tray" : "Close app",
-        expandTools: snapshot.expandToolsDefault !== false
+        expandTools: snapshot.expandToolsDefault !== false,
+        remoteTouch: snapshot.remoteTouchEnabled !== false
       },
       personalization: {
         theme: { light: "Light", system: "System", dark: "Dark" }[String(snapshot.darkMode || "dark").toLowerCase()] || "Dark",
@@ -1071,6 +1072,25 @@ function toggleSelected(state) {
     }
     const row = settingsRows(state)[state.selected];
     if (!row) return;
+    if (row.action === "pair-mobile") {
+      state.overlay = "pair";
+      state.pairingQrLines = ["Loading pairing QR…"];
+      state.pairingUrl = "";
+      state.pairingTokenFile = "";
+      if (typeof state.adapter.pairingQr !== "function") {
+        state.pairingQrLines = ["Pairing QR is unavailable in this adapter."];
+        return false;
+      }
+      return Promise.resolve(state.adapter.pairingQr()).then((pairing) => {
+        state.pairingQrLines = String(pairing?.ascii || "").split(/\r?\n/);
+        state.pairingUrl = String(pairing?.url || "");
+        state.pairingTokenFile = String(pairing?.tokenFile || "");
+        return true;
+      }).catch((error) => {
+        state.pairingQrLines = [`Pairing failed: ${error?.message || error}`];
+        return false;
+      });
+    }
     if (state.settingsTab === "general" && row.key === "inputBehavior") {
       const current = row.choices.findIndex((value) => value === row.value);
       state.settingChoiceTab = state.settingsTab;