orquesta-cli 0.2.39 → 0.2.41

package/dist/agents/planner/index.d.ts

@@ -14,5 +14,6 @@ export declare class PlanningLLM {
     generateTODOList(userRequest: string, contextMessages?: Message[]): Promise<PlanningResult>;
     generateTODOListWithDocsDecision(userRequest: string, contextMessages?: Message[]): Promise<PlanningWithDocsResult>;
 }
+export declare function extractLeakedToolCallName(text: string): string | null;
 export default PlanningLLM;
 //# sourceMappingURL=index.d.ts.map

package/dist/agents/planner/index.js

@@ -195,6 +195,14 @@ Choose one of your 3 tools now.`,
                                 lastError = new Error('Planning LLM returned empty response.');
                                 continue;
                             }
+                            const leakedTool = extractLeakedToolCallName(responseText);
+                            if (leakedTool) {
+                                logger.warn('respond_to_user response is a leaked tool-call JSON', { leakedTool });
+                                lastError = new Error(`You attempted to call '${leakedTool}', which is an Execution LLM tool. ` +
+                                    `As the PLANNING LLM you must use create_todos for action requests ` +
+                                    `(the Execution LLM will run '${leakedTool}' for you) or respond_to_user with plain prose.`);
+                                continue;
+                            }
                             return {
                                 todos: [],
                                 complexity: 'simple',
@@ -254,5 +262,54 @@ Choose one of your 3 tools now.`,
         };
     }
 }
+const PLANNING_TOOL_NAMES = new Set(['ask_to_user', 'create_todos', 'respond_to_user']);
+export function extractLeakedToolCallName(text) {
+    for (let start = text.indexOf('{'); start !== -1; start = text.indexOf('{', start + 1)) {
+        const end = findBalancedObjectEnd(text, start);
+        if (end === -1)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text.slice(start, end + 1));
+        }
+        catch {
+            continue;
+        }
+        if (parsed && typeof parsed === 'object') {
+            const tool = parsed.tool;
+            if (typeof tool === 'string' && tool && !PLANNING_TOOL_NAMES.has(tool))
+                return tool;
+            start = end;
+        }
+    }
+    return null;
+}
+function findBalancedObjectEnd(s, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < s.length; i++) {
+        const c = s[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (c === '\\')
+                escaped = true;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"')
+            inString = true;
+        else if (c === '{')
+            depth++;
+        else if (c === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
 export default PlanningLLM;
 //# sourceMappingURL=index.js.map

package/dist/core/slash-command-handler.js

@@ -8,6 +8,7 @@ import { createRequire } from 'module';
 import { configManager } from './config/config-manager.js';
 import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
 import { auditLog } from '../orchestration/audit-log.js';
+import { remotePhone } from '../orquesta/remote-phone.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
@@ -591,6 +592,40 @@ ${executorLines}
         }
         return reply('Usage: /hook status | /hook enable | /hook disable\nThe hook mirrors claude AND orquesta sessions in this directory into your project.\n(To move a directory to a different project, run `orquesta hook switch` in a shell.)');
     }
+    if (trimmedCommand === '/remote-phone' || trimmedCommand.startsWith('/remote-phone ')) {
+        logger.flow('Remote-phone command received');
+        const sub = (trimmedCommand.split(/\s+/)[1] || 'on').toLowerCase();
+        const reply = (content) => {
+            const updatedMessages = [...context.messages, { role: 'assistant', content }];
+            context.setMessages(updatedMessages);
+            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+        };
+        if (sub === 'status') {
+            return reply(remotePhone.isActive()
+                ? '📱 Remote phone: ACTIVE — listening for your phone messages and replying to the channel.\n  Stop it with /remote-phone off.'
+                : '📱 Remote phone: not active. Start it with /remote-phone on.');
+        }
+        if (sub === 'off' || sub === 'stop') {
+            if (!remotePhone.isActive())
+                return reply('Nothing to do — no remote phone channel is active.');
+            await remotePhone.close();
+            return reply('📱 Remote phone channel closed. Your phone can no longer drive this session.');
+        }
+        try {
+            const h = await remotePhone.open();
+            return reply([
+                '📱 Remote phone channel is LIVE — drive this session from your phone.',
+                '',
+                h.operatorHandoff,
+                ...(h.qrAsciiClean ? ['', h.qrAsciiClean] : []),
+                '',
+                `Channel: ${h.channelId} · PIN: ${h.pin} · valid 24h. Stop anytime with /remote-phone off.`,
+            ].join('\n'));
+        }
+        catch (e) {
+            return reply(`❌ Could not open the remote phone channel: ${e.message}`);
+        }
+    }
     if (trimmedCommand === '/help') {
         const helpMessage = `
 Available commands:
@@ -610,6 +645,7 @@ Available commands:
   /logout         - Sign out of Orquesta (clears token, keeps local LLM configs)
   /whoami         - Show current Orquesta connection
   /hook           - Claude Code hook here: /hook status | enable | disable
+  /remote-phone   - Drive this session from your phone: on | off | status
   /update         - Update orquesta-cli to the latest version
 
 Keyboard shortcuts:

package/dist/orquesta/remote-phone.d.ts

@@ -0,0 +1,52 @@
+export declare const DEFAULT_REMOTE_ORIGIN = "https://rogerthat.chat";
+export interface RemotePhoneMessage {
+    id: number;
+    from: string;
+    text: string;
+    at: number;
+}
+export interface RemotePhoneHandoff {
+    channelId: string;
+    mobileUrl: string;
+    mobileUrlProtected: string;
+    pin: string;
+    operatorHandoff: string;
+    qrAsciiClean?: string;
+    origin: string;
+}
+type MessageListener = (msg: RemotePhoneMessage) => void;
+type NoticeListener = (text: string) => void;
+declare class RemotePhoneController {
+    private origin;
+    private channelId;
+    private channelToken;
+    private callsign;
+    private identityKey;
+    private ownerPassword;
+    private sessionId;
+    private receiving;
+    private abort;
+    private lastSeenId;
+    private lastPostedReply;
+    private messageListeners;
+    private noticeListeners;
+    isActive(): boolean;
+    onMessage(cb: MessageListener): () => void;
+    onNotice(cb: NoticeListener): () => void;
+    private notice;
+    open(opts?: {
+        origin?: string;
+    }): Promise<RemotePhoneHandoff>;
+    private cachedHandoff;
+    private buildHandoff;
+    private join;
+    private startReceiving;
+    private receiveLoop;
+    postReply(text: string): Promise<void>;
+    sendStatus(text: string): Promise<void>;
+    private send;
+    close(): Promise<void>;
+}
+export declare const remotePhone: RemotePhoneController;
+export {};
+//# sourceMappingURL=remote-phone.d.ts.map

package/dist/orquesta/remote-phone.js

@@ -0,0 +1,214 @@
+import { logger } from '../utils/logger.js';
+export const DEFAULT_REMOTE_ORIGIN = 'https://rogerthat.chat';
+class RemotePhoneController {
+    origin = DEFAULT_REMOTE_ORIGIN;
+    channelId = null;
+    channelToken = null;
+    callsign = null;
+    identityKey = null;
+    ownerPassword = null;
+    sessionId = null;
+    receiving = false;
+    abort = null;
+    lastSeenId = 0;
+    lastPostedReply = '';
+    messageListeners = new Set();
+    noticeListeners = new Set();
+    isActive() {
+        return this.channelId !== null && this.receiving;
+    }
+    onMessage(cb) {
+        this.messageListeners.add(cb);
+        return () => this.messageListeners.delete(cb);
+    }
+    onNotice(cb) {
+        this.noticeListeners.add(cb);
+        return () => this.noticeListeners.delete(cb);
+    }
+    notice(text) {
+        for (const cb of this.noticeListeners) {
+            try {
+                cb(text);
+            }
+            catch { }
+        }
+    }
+    async open(opts) {
+        if (this.isActive() && this.channelId) {
+            return this.buildHandoff(this.cachedHandoff);
+        }
+        this.origin = (opts?.origin || DEFAULT_REMOTE_ORIGIN).replace(/\/+$/, '');
+        logger.flow('remote-phone: minting channel', { origin: this.origin });
+        const res = await fetch(`${this.origin}/api/remote-control`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: '{}',
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`remote-control mint failed: HTTP ${res.status} ${body.slice(0, 200)}`);
+        }
+        const bundle = (await res.json());
+        if (!bundle.channel_id || !bundle.channel_token || !bundle.agent?.identity_key) {
+            throw new Error('remote-control response missing channel/agent fields');
+        }
+        this.channelId = bundle.channel_id;
+        this.channelToken = bundle.channel_token;
+        this.callsign = bundle.agent.callsign;
+        this.identityKey = bundle.agent.identity_key;
+        this.ownerPassword = bundle.owner_password;
+        this.lastSeenId = 0;
+        this.lastPostedReply = '';
+        this.cachedHandoff = bundle;
+        await this.join();
+        this.startReceiving();
+        return this.buildHandoff(bundle);
+    }
+    cachedHandoff = null;
+    buildHandoff(b) {
+        return {
+            channelId: b.channel_id,
+            mobileUrl: b.mobile_url,
+            mobileUrlProtected: b.mobile_url_protected,
+            pin: b.owner_password,
+            operatorHandoff: b.operator_handoff,
+            qrAsciiClean: b.qr_ascii_clean,
+            origin: this.origin,
+        };
+    }
+    async join() {
+        const res = await fetch(`${this.origin}/api/channels/${this.channelId}/join`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.channelToken}`,
+                'Content-Type': 'application/json',
+                ...(this.sessionId ? { 'X-Session-Id': this.sessionId } : {}),
+            },
+            body: JSON.stringify({
+                callsign: this.callsign,
+                identity_key: this.identityKey,
+                owner_password: this.ownerPassword,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`channel join failed: HTTP ${res.status} ${body.slice(0, 200)}`);
+        }
+        const data = (await res.json());
+        if (!data.session_id)
+            throw new Error('join response missing session_id');
+        this.sessionId = data.session_id;
+        logger.flow('remote-phone: joined channel', { channelId: this.channelId, callsign: this.callsign });
+    }
+    startReceiving() {
+        if (this.receiving)
+            return;
+        this.receiving = true;
+        this.abort = new AbortController();
+        void this.receiveLoop();
+    }
+    async receiveLoop() {
+        let backoff = 1000;
+        while (this.receiving) {
+            try {
+                const url = `${this.origin}/api/channels/${this.channelId}/wait?timeout=120` +
+                    (this.lastSeenId ? `&since=${this.lastSeenId}` : '');
+                const res = await fetch(url, {
+                    headers: {
+                        'Authorization': `Bearer ${this.channelToken}`,
+                        'X-Session-Id': this.sessionId,
+                    },
+                    signal: this.abort?.signal,
+                });
+                if (res.status === 401 || res.status === 410) {
+                    logger.flow('remote-phone: session expired, rejoining');
+                    await this.join();
+                    continue;
+                }
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    throw new Error(`wait failed: HTTP ${res.status} ${body.slice(0, 160)}`);
+                }
+                const data = (await res.json());
+                backoff = 1000;
+                for (const m of data.messages || []) {
+                    if (m.id > this.lastSeenId)
+                        this.lastSeenId = m.id;
+                    if (m.kind === 'status')
+                        continue;
+                    const msg = { id: m.id, from: m.from, text: m.text, at: m.at };
+                    for (const cb of this.messageListeners) {
+                        try {
+                            cb(msg);
+                        }
+                        catch (e) {
+                            logger.warn(`remote-phone message listener error: ${e}`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                if (!this.receiving)
+                    break;
+                const err = e;
+                if (err.name === 'AbortError')
+                    break;
+                logger.warn(`remote-phone receive loop error: ${err.message}`);
+                this.notice(`📱 Remote phone: reconnecting (${err.message})`);
+                await new Promise((r) => setTimeout(r, backoff));
+                backoff = Math.min(backoff * 2, 30000);
+            }
+        }
+        logger.flow('remote-phone: receive loop ended');
+    }
+    async postReply(text) {
+        if (!this.isActive() || !text.trim())
+            return;
+        const trimmed = text.trim();
+        if (trimmed === this.lastPostedReply)
+            return;
+        this.lastPostedReply = trimmed;
+        await this.send(trimmed.slice(0, 8000));
+    }
+    async sendStatus(text) {
+        if (!this.isActive())
+            return;
+        await this.send(text.slice(0, 280), 'status');
+    }
+    async send(message, kind) {
+        try {
+            await fetch(`${this.origin}/api/channels/${this.channelId}/send`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.channelToken}`,
+                    'X-Session-Id': this.sessionId,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ to: 'all', message, ...(kind ? { kind } : {}) }),
+            });
+        }
+        catch (e) {
+            logger.warn(`remote-phone send failed: ${e.message}`);
+        }
+    }
+    async close() {
+        if (!this.channelId)
+            return;
+        this.receiving = false;
+        this.abort?.abort();
+        const id = this.channelId, token = this.channelToken, sid = this.sessionId;
+        this.channelId = this.channelToken = this.sessionId = null;
+        this.callsign = this.identityKey = this.ownerPassword = null;
+        this.cachedHandoff = null;
+        this.notice('📱 Remote phone channel closed.');
+        try {
+            await fetch(`${this.origin}/api/channels/${id}/leave`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${token}`, 'X-Session-Id': sid },
+            });
+        }
+        catch { }
+    }
+}
+export const remotePhone = new RemotePhoneController();
+//# sourceMappingURL=remote-phone.js.map

package/dist/tools/llm/simple/remote-phone-tool.d.ts

@@ -0,0 +1,4 @@
+import { LLMSimpleTool } from '../../types.js';
+export declare const RemotePhoneTool: LLMSimpleTool;
+export default RemotePhoneTool;
+//# sourceMappingURL=remote-phone-tool.d.ts.map

package/dist/tools/llm/simple/remote-phone-tool.js

@@ -0,0 +1,55 @@
+import { logger } from '../../../utils/logger.js';
+import { remotePhone } from '../../../orquesta/remote-phone.js';
+const DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'open_remote_phone_channel',
+        description: 'Open a RogerThat remote-control channel so the user can drive this session from their phone. ' +
+            'Use this when the user asks to "drive you from my phone", "open a remote channel", or set up ' +
+            'phone/mobile control. It mints the channel, starts listening for phone messages in-process, and ' +
+            'returns a handoff block with the link and PIN. After calling it, relay the returned operator_handoff ' +
+            'text to the user verbatim (it contains both the one-tap link and the PIN-protected link). ' +
+            'Do NOT use curl, npx rogerthat, or background tail/waiter loops — this tool handles all of that.',
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Why you are opening the channel (shown to the user).',
+                },
+            },
+            required: [],
+        },
+    },
+};
+async function execute() {
+    logger.enter('open_remote_phone_channel');
+    try {
+        const handoff = await remotePhone.open();
+        const result = [
+            'Remote phone channel is LIVE. Relay this to the user verbatim:',
+            '',
+            handoff.operatorHandoff,
+            '',
+            `Channel: ${handoff.channelId} · PIN: ${handoff.pin} · valid 24h.`,
+            'You are now listening for their phone messages and will reply to the channel automatically.',
+        ].join('\n');
+        return { success: true, result, metadata: { channelId: handoff.channelId } };
+    }
+    catch (e) {
+        const err = e;
+        logger.warn(`open_remote_phone_channel failed: ${err.message}`);
+        return {
+            success: false,
+            error: `Could not open the remote phone channel: ${err.message}`,
+        };
+    }
+}
+export const RemotePhoneTool = {
+    definition: DEFINITION,
+    execute,
+    categories: ['llm-simple'],
+    description: 'Open a RogerThat remote-control channel for phone-driven control',
+};
+export default RemotePhoneTool;
+//# sourceMappingURL=remote-phone-tool.js.map

package/dist/tools/registry.js

@@ -7,6 +7,7 @@ import { USER_INTERACTION_TOOLS } from './llm/simple/user-interaction-tools.js';
 import { TODO_TOOLS } from './llm/simple/todo-tools.js';
 import { PLANNING_TOOLS } from './llm/simple/planning-tools.js';
 import { FinalResponseTool } from './llm/simple/final-response-tool.js';
+import { RemotePhoneTool } from './llm/simple/remote-phone-tool.js';
 import { getShellTools } from './llm/simple/index.js';
 import { BROWSER_TOOLS, startBrowserServer, shutdownBrowserServer } from './browser/index.js';
 import { WORD_TOOLS, EXCEL_TOOLS, POWERPOINT_TOOLS } from './office/index.js';
@@ -261,6 +262,7 @@ export function initializeToolRegistry() {
     toolRegistry.registerAll(shellTools);
     toolRegistry.registerAll(TODO_TOOLS);
     toolRegistry.register(FinalResponseTool);
+    toolRegistry.register(RemotePhoneTool);
     toolRegistry.registerAll(PLANNING_TOOLS);
 }
 export async function initializeOptionalTools() {

package/dist/ui/components/PlanExecuteApp.js

@@ -35,6 +35,7 @@ import { executeSlashCommand, isSlashCommand, } from '../../core/slash-command-h
 import { closeJsonStreamLogger } from '../../utils/json-stream-logger.js';
 import { configManager } from '../../core/config/config-manager.js';
 import { readHookConfig } from '../../orquesta/hook-init.js';
+import { remotePhone } from '../../orquesta/remote-phone.js';
 import { logger } from '../../utils/logger.js';
 import { usageTracker } from '../../core/usage-tracker.js';
 import { UpdateNotification } from '../UpdateNotification.js';
@@ -150,6 +151,9 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     }), []);
     const lastCtrlCTimeRef = React.useRef(0);
     const DOUBLE_TAP_THRESHOLD = 1500;
+    const handleSubmitRef = React.useRef(() => { });
+    const lastPhonePostedIdxRef = React.useRef(-1);
+    const phoneWasActiveRef = React.useRef(false);
     const addLog = useCallback((entry) => {
         if (!entry.content || entry.content.trim() === '') {
             return;
@@ -475,6 +479,8 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
     }, []);
     const handleExit = useCallback(async () => {
         logger.flow('Exiting application');
+        if (remotePhone.isActive())
+            await remotePhone.close().catch(() => { });
         await closeJsonStreamLogger();
         exit();
     }, [exit]);
@@ -990,6 +996,49 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
         handleExit,
         addLog,
     ]);
+    useEffect(() => {
+        handleSubmitRef.current = handleSubmit;
+    }, [handleSubmit]);
+    useEffect(() => {
+        const offMessage = remotePhone.onMessage((msg) => {
+            logger.flow('remote-phone: injecting phone message as user turn', { from: msg.from });
+            addLog({ type: 'user_input', content: `📱 ${msg.text}` });
+            void remotePhone.sendStatus('on it');
+            handleSubmitRef.current(msg.text);
+        });
+        const offNotice = remotePhone.onNotice((text) => {
+            addLog({ type: 'assistant_message', content: text });
+        });
+        return () => { offMessage(); offNotice(); };
+    }, [addLog]);
+    useEffect(() => {
+        const active = remotePhone.isActive();
+        if (active && !phoneWasActiveRef.current) {
+            phoneWasActiveRef.current = true;
+            lastPhonePostedIdxRef.current = messages.length - 1;
+            return;
+        }
+        if (!active) {
+            phoneWasActiveRef.current = false;
+            return;
+        }
+        if (isProcessing)
+            return;
+        let lastAssistantIdx = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i]?.role === 'assistant') {
+                lastAssistantIdx = i;
+                break;
+            }
+        }
+        if (lastAssistantIdx <= lastPhonePostedIdxRef.current)
+            return;
+        const content = messages[lastAssistantIdx]?.content;
+        if (content && content.trim()) {
+            lastPhonePostedIdxRef.current = lastAssistantIdx;
+            void remotePhone.postReply(content);
+        }
+    }, [messages, isProcessing]);
     useEffect(() => {
         if (!isProcessing && pendingUserMessage && llmClient) {
             logger.flow('Processing remaining pending user message after execution complete');

package/dist/ui/hooks/slashCommandProcessor.js

@@ -61,6 +61,11 @@ export const SLASH_COMMANDS = [
         name: '/hook',
         description: 'Claude Code hook here: status | enable | disable',
     },
+    {
+        name: '/remote-phone',
+        description: 'Drive this session from your phone (RogerThat): on | off | status',
+        argsHint: 'on | off | status',
+    },
     {
         name: '/update',
         description: 'Update orquesta-cli to the latest version',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",