termdock 1.4.356 → 1.4.357

package/dist/server/agent/sessionChatRoutes.js

@@ -23,15 +23,53 @@ export function sessionChatRoutes(options) {
             return;
         }
         const group = options.store.list().find(g => g.name === ctx.groupName && !g.federated && g.sessionIds.length === 1 && g.sessionIds[0] === ctx.session.sessionId);
-        const canSeeRequest = (message) => message?.integrationOrigin?.source === 'session-chat';
-        const messages = group ? options.store.listMessages(group.id, 500).filter(message => {
-            if (canSeeRequest(message))
+        const paged = req.query.limit !== undefined;
+        const limit = paged ? Number(req.query.limit) : 500;
+        const before = req.query.before, after = req.query.after, requestId = req.query.requestId;
+        if (paged && (typeof req.query.limit !== 'string' || !/^\d{1,2}$/.test(req.query.limit) || limit < 1 || limit > 60
+            || before !== undefined && (typeof before !== 'string' || before.length > 128)
+            || after !== undefined && (typeof after !== 'string' || after.length > 128)
+            || before !== undefined && after !== undefined
+            || requestId !== undefined && (typeof requestId !== 'string' || !/^[a-zA-Z0-9_-]{16,100}$/.test(requestId)))) {
+            res.status(400).json({ error: '对话分页参数无效' });
+            return;
+        }
+        const history = group ? options.store.listGroupMessages(group.id) : [];
+        const originals = new Map(history.map(message => [message.id, message]));
+        const visible = history.filter(message => {
+            if (message.integrationOrigin?.source === 'session-chat')
                 return true;
-            const original = message.toPrincipalId && message.replyTo ? options.store.getMessage(message.replyTo) : null;
-            return original?.groupId === group.id && message.toPrincipalId === original.integrationOrigin?.integrationId && canSeeRequest(original);
-        }).map(m => ({ id: m.id, role: m.toPrincipalId ? 'assistant' : 'user', ...(m.toPrincipalId ? chatPresentation(m.content, m.metadata) : { content: m.content }), ...(m.uiState ? { uiState: m.uiState } : {}), createdAt: m.createdAt, status: m.status === 'read' ? 'delivered' : m.status, replyTo: m.replyTo, requestId: m.idempotencyKey, responseKind: m.responseKind })) : [];
+            const original = message.toPrincipalId && message.replyTo ? originals.get(message.replyTo) : null;
+            return original?.groupId === group?.id && message.toPrincipalId === original?.integrationOrigin?.integrationId && original?.integrationOrigin?.source === 'session-chat';
+        });
+        const cursor = before ?? after;
+        const anchor = cursor === undefined ? -1 : visible.findIndex(message => message.id === cursor);
+        if (paged && cursor !== undefined && anchor < 0) {
+            res.status(404).json({ error: '这段对话已不可用，请返回最新消息', code: 'CHAT_CURSOR_UNAVAILABLE' });
+            return;
+        }
+        const end = !paged || cursor === undefined ? visible.length : before !== undefined ? anchor : Math.min(visible.length, anchor + 1 + limit);
+        const start = paged && after !== undefined ? anchor + 1 : Math.max(0, end - limit);
+        const project = (m) => ({ id: m.id, role: m.toPrincipalId ? 'assistant' : 'user', ...(m.toPrincipalId ? chatPresentation(m.content, m.metadata) : { content: m.content }), ...(m.uiState ? { uiState: m.uiState } : {}), createdAt: m.createdAt, status: m.status === 'read' ? 'delivered' : m.status, replyTo: m.replyTo, requestId: m.idempotencyKey, responseKind: m.responseKind, ...(paged ? { sequence: m.sequence } : {}) });
+        const messages = visible.slice(start, end).map(project);
+        // Refresh only the small tail already displayed, including delivery and
+        // form revisions, while fetching subsequent replies contiguously.
+        const updates = paged && after !== undefined ? visible.slice(Math.max(0, anchor + 1 - limit), anchor + 1).map(project) : undefined;
+        const page = paged ? { hasOlder: start > 0, hasNewer: end < visible.length, mode: before !== undefined ? 'before' : after !== undefined ? 'after' : 'latest' } : undefined;
+        let lastRequest;
+        for (let index = visible.length - 1; index >= 0; index--)
+            if (!visible[index].toPrincipalId) {
+                lastRequest = visible[index];
+                break;
+            }
+        const replyPending = !!lastRequest && !['failed', 'expired'].includes(lastRequest.status) && !visible.some(message => message.toPrincipalId && message.replyTo === lastRequest.id && !['ack', 'progress'].includes(message.responseKind || ''));
+        const confirmedRequestId = paged && typeof requestId === 'string' && visible.some(message => !message.toPrincipalId && message.idempotencyKey === requestId) ? requestId : undefined;
+        const payload = { messages, ...(updates ? { updates } : {}), ...(page ? { page, replyPending, ...(confirmedRequestId ? { confirmedRequestId } : {}) } : {}), agentAvailable: !!ctx.session.agent, agent: ctx.session.agent ? { slug: ctx.session.agent.slug, displayName: ctx.session.agent.displayName || ctx.session.agent.slug } : null };
+        const revision = createHash('sha256').update(JSON.stringify(payload)).digest('base64url');
         res.setHeader('Cache-Control', 'no-store');
-        res.json({ messages, agentAvailable: !!ctx.session.agent, agent: ctx.session.agent ? { slug: ctx.session.agent.slug, displayName: ctx.session.agent.displayName || ctx.session.agent.slug } : null });
+        // A JSON acknowledgement works inside the encrypted transport and keeps
+        // older clients compatible; no HTTP cache contains conversation bodies.
+        res.json(req.query.revision === revision ? { unchanged: true, revision } : { ...payload, revision });
     });
     router.put('/:sessionId/chat/:messageId/state', (req, res) => {
         const ctx = context(req), body = req.body;

package/dist/server/agentHook.js

@@ -48,6 +48,19 @@ const MAX_STDIN = 64 * 1024;
  * asking the user a question) survives there.
  */
 function effectiveEvent(agent, event, stdinJson) {
+    // These tools ask a question without opening a permission dialog. Ordinary
+    // tool starts must stay silent so they cannot manufacture a waiting state.
+    if (event === 'tool-start') {
+        try {
+            const tool = JSON.parse(stdinJson)?.tool_name;
+            return (agent === 'claude' && tool === 'AskUserQuestion')
+                || (agent === 'codex' && tool === 'request_user_input')
+                ? 'question-asked' : null;
+        }
+        catch {
+            return null;
+        }
+    }
     if ((agent === 'copilot' || agent === 'grok') && event === 'notification') {
         const blocks = stdinJson.includes('elicitation_dialog')
             || (agent === 'copilot' && stdinJson.includes('permission_prompt'));
@@ -56,11 +69,29 @@ function effectiveEvent(agent, event, stdinJson) {
     return event;
 }
 /** Write raw bytes to a tty device, best-effort. */
-function writeDev(path, bytes) {
+async function writeDev(path, bytes) {
     try {
-        const fd = fs.openSync(path, 'w');
+        // A leftover tmux client may no longer drain its PTY. It must not block
+        // this hook before the current observer gets its copy of the event.
+        const fd = fs.openSync(path, fs.constants.O_WRONLY | fs.constants.O_NONBLOCK | fs.constants.O_NOCTTY);
         try {
-            fs.writeSync(fd, bytes);
+            const buffer = Buffer.from(bytes);
+            let offset = 0;
+            const deadline = Date.now() + 250;
+            while (offset < buffer.length) {
+                try {
+                    const written = fs.writeSync(fd, buffer, offset, buffer.length - offset);
+                    if (written <= 0)
+                        return false;
+                    offset += written;
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (!['EAGAIN', 'EWOULDBLOCK', 'EINTR'].includes(code ?? '') || Date.now() >= deadline)
+                        return false;
+                    await new Promise(resolve => setTimeout(resolve, 2));
+                }
+            }
         }
         finally {
             fs.closeSync(fd);
@@ -156,26 +187,29 @@ function tmuxClientTtyDevices() {
  * enabled, as termdock sets on managed sessions) forwards to its client —
  * the termdock server — as the plain inner OSC.
  */
-function writeToControllingTty(sequence, inTmuxPane) {
+async function writeToControllingTty(sequence, inTmuxPane) {
     if (inTmuxPane) {
         const clientTtys = tmuxClientTtyDevices();
-        if (clientTtys.length > 0) {
-            return clientTtys.some((device) => writeDev(device, sequence));
-        }
+        // A surviving client from a previous server may be listed first. Deliver
+        // to every managed observer; short-circuiting at the first successful
+        // write leaves the current server without any lifecycle events.
+        const delivered = await Promise.all(clientTtys.map(device => writeDev(device, sequence)));
+        if (delivered.includes(true))
+            return true;
     }
     // Only genuine tmux panes (TMUX_PANE is set by tmux itself) get the DCS
     // passthrough wrap; a bare inherited TMUX just means an ancestor ran tmux.
     const wire = inTmuxPane
         ? `\x1bPtmux;${sequence.replace(/\x1b/g, '\x1b\x1b')}\x1b\\`
         : sequence;
-    if (writeDev('/dev/tty', wire))
+    if (await writeDev('/dev/tty', wire))
         return true;
     const dev = ancestorTtyDevice();
     if (dev)
         return writeDev(dev, wire);
     return false;
 }
-function main() {
+async function main() {
     try {
         // Gate: emit when (a) inside a termdock-spawned shell (TERMDOCK env), or
         // (b) inside any tmux pane (TMUX+TMUX_PANE) — there the passthrough wrap
@@ -205,18 +239,28 @@ function main() {
         let input = '';
         if (!process.stdin.isTTY) {
             try {
-                input = fs.readFileSync(0, 'utf8').slice(0, MAX_STDIN);
+                const chunks = [];
+                let size = 0;
+                for await (const chunk of process.stdin) {
+                    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    const part = bytes.subarray(0, MAX_STDIN - size);
+                    chunks.push(part);
+                    size += part.length;
+                    if (size >= MAX_STDIN)
+                        break;
+                }
+                input = Buffer.concat(chunks).toString('utf8');
             }
             catch { /* no payload */ }
         }
         const event = effectiveEvent(agent, eventArg, input);
         if (!event)
             return;
-        writeToControllingTty(buildHookSequence(agent, event, input, statusArg || undefined), inTmuxPane);
+        await writeToControllingTty(buildHookSequence(agent, event, input, statusArg || undefined), inTmuxPane);
     }
     catch {
         // Never break the agent's flow.
     }
     process.exit(0);
 }
-main();
+void main();

package/dist/server/android/adb.js

@@ -2,7 +2,7 @@ import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { promisify } from 'node:util';
-import { isIP } from 'node:net';
+import { normalizeAndroidAddress } from '../shared/androidDevices.js';
 import { createHash } from 'node:crypto';
 const execFileAsync = promisify(execFile);
 const EXTRA_PATH = ['/usr/local/bin', '/opt/homebrew/bin', '/opt/local/bin', '/usr/bin', '/usr/lib/android-sdk/platform-tools'];
@@ -117,6 +117,8 @@ export async function getDeviceProperties(serial) {
         return {};
     }
 }
+const deviceIdentities = new Map();
+const IDENTITY_TTL = 5 * 60_000;
 export async function listDevices() {
     const output = await runAdb(['devices', '-l'], { timeout: 10_000 });
     const devices = [];
@@ -127,9 +129,27 @@ export async function listDevices() {
         if (info)
             devices.push(info);
     }
-    await Promise.all(devices.filter(device => device.state === 'device').map(async (device) => {
-        Object.assign(device, await getDeviceProperties(device.serial));
+    const now = Date.now();
+    for (const [key, value] of deviceIdentities)
+        if (now - value.observed > IDENTITY_TTL)
+            deviceIdentities.delete(key);
+    const namespace = resolveAdbBinary() || '';
+    await Promise.all(devices.map(async (device) => {
+        const key = `${namespace}:${device.serial}`;
+        if (device.state === 'device') {
+            Object.assign(device, await getDeviceProperties(device.serial));
+            deviceIdentities.delete(key);
+            if (device.physicalId)
+                deviceIdentities.set(key, { physicalId: device.physicalId, observed: now });
+        }
+        else {
+            const previous = deviceIdentities.get(key);
+            if (previous)
+                device.physicalId = previous.physicalId;
+        }
     }));
+    while (deviceIdentities.size > 512)
+        deviceIdentities.delete(deviceIdentities.keys().next().value);
     return devices;
 }
 export async function connectDevice(address) {
@@ -148,31 +168,4 @@ export async function disconnectDevice(address) {
     return (await runAdb(['disconnect', normalized], { timeout: 10_000 })).trim();
 }
 /** 接受 `ip:port`、纯 ip（补 5555）、或带 scheme/路径的粘贴内容。 */
-export function normalizeAddress(raw) {
-    let value = raw.trim();
-    if (!value)
-        return null;
-    const urlMatch = /^[a-z]+:\/\/([^/]+)/i.exec(value);
-    if (urlMatch)
-        value = urlMatch[1];
-    value = value.replace(/^\/+|\/+$/g, '');
-    const ipv6 = /^\[([^\]]+)\](?::(\d{1,5}))?$/.exec(value);
-    if (ipv6) {
-        if (isIP(ipv6[1]) !== 6)
-            return null;
-        const port = ipv6[2] ?? '5555';
-        if (Number(port) < 1 || Number(port) > 65535)
-            return null;
-        return `[${ipv6[1]}]:${port}`;
-    }
-    if (!/^[0-9a-zA-Z_.\-]+(?::\d+)?$/.test(value))
-        return null;
-    if (!value.includes(':') && /^\d+\.\d+\.\d+\.\d+$/.test(value))
-        value = `${value}:5555`;
-    const [host, port] = value.split(':');
-    if (port !== undefined && !/^\d{1,5}$/.test(port))
-        return null;
-    if (!host)
-        return null;
-    return port === undefined ? `${host}:5555` : `${host}:${port}`;
-}
+export const normalizeAddress = normalizeAndroidAddress;

package/dist/server/cli.js

@@ -26,7 +26,7 @@ import { detectLocalSessionContext, resolveLocalCollaborationContext } from './a
 import { parseAutomationCommand, executeAutomationCommand, AUTOMATION_HELP } from './agent/automationCli.js';
 import { parseCollaborationCommand, executeCollaborationCommand, COLLAB_HELP } from './agent/collaborationCli.js';
 import fs from 'fs';
-import { getMissingCertificateNames } from './utils/certificateNames.js';
+import { localCertificateNeedsRefresh, setupLocalHttps } from './utils/localHttpsSetup.js';
 import http from 'http';
 import https from 'https';
 import path from 'path';
@@ -140,7 +140,8 @@ Options:
   --https-key <p>    HTTPS private key path for local access
   --https-ca <p>     CA certificate path exposed through a temporary mobile setup server
   --setup-local-https
-                     Generate and trust local HTTPS certs with mkcert
+                     Generate local HTTPS certs; install verified mkcert if needed
+  --no-install-ca     Generate certificates without changing local trust stores
   --foreground       Run in the foreground
   --supervise        Like --foreground, but under the process supervisor
                      (auto-restarts on crash, records why). Use this for
@@ -189,7 +190,7 @@ Options:
   --plugin-create <file>
                      Create a plugin from a manifest JSON file
   --plugin-install <source>
-                     Install a complete plugin package from HTTPS Git or a local path
+                     Install a plugin package from Git (HTTPS/HTTP/SSH) or a local path
   --plugin-list      List installed agent plugins
   --plugin-check <slug>
                      Check the installed plugin source for updates
@@ -410,54 +411,6 @@ function resolveHealthTarget(options, https) {
     const displayHost = host === '0.0.0.0' ? 'localhost' : host;
     return { url: `${scheme}://${displayHost}:${port}/health`, scheme, host: displayHost, port };
 }
-const EXTRA_EXECUTABLE_DIRS = ['/opt/homebrew/bin', '/usr/local/bin'];
-function executableCandidates(command) {
-    if (command.includes(path.sep))
-        return [command];
-    const dirs = [...(process.env.PATH ?? '').split(path.delimiter), ...EXTRA_EXECUTABLE_DIRS].filter(Boolean);
-    const seen = new Set();
-    return dirs
-        .map((dir) => path.join(dir, command))
-        .filter((candidate) => {
-        if (seen.has(candidate))
-            return false;
-        seen.add(candidate);
-        return true;
-    });
-}
-async function findExecutable(command) {
-    for (const candidate of executableCandidates(command)) {
-        try {
-            await execFileAsync(candidate, ['--version'], { timeout: 5000, maxBuffer: 128 * 1024 });
-            return candidate;
-        }
-        catch { /* try next candidate */ }
-    }
-    return null;
-}
-async function ensureMkcertInstalled() {
-    const existing = await findExecutable('mkcert');
-    if (existing)
-        return existing;
-    const brew = await findExecutable('brew');
-    if (!brew) {
-        throw new Error(`${ICON.err} ${c.red('mkcert is required for local HTTPS setup, and Homebrew was not found.')}\n  ${c.dim('Install Homebrew first, or manually install:')} ${c.cyan('brew install mkcert')}`);
-    }
-    console.log(`${ICON.info} ${c.dim('mkcert is not installed. Installing with Homebrew...')}`);
-    try {
-        await execFileAsync(brew, ['install', 'mkcert'], { timeout: 10 * 60 * 1000, maxBuffer: 8 * 1024 * 1024 });
-    }
-    catch (error) {
-        const err = error;
-        const detail = (err.stderr || err.message || '').toString().trim();
-        throw new Error(`${ICON.err} ${c.red('Failed to install mkcert with Homebrew.')}${detail ? `\n${detail}` : ''}`);
-    }
-    const installed = await findExecutable('mkcert');
-    if (!installed) {
-        throw new Error(`${ICON.err} ${c.red('mkcert installation completed, but mkcert was not found on PATH.')}`);
-    }
-    return installed;
-}
 function getRequiredLocalHttpsNames() {
     const localName = getLocalAccessSetting().name;
     return [
@@ -469,62 +422,32 @@ function getRequiredLocalHttpsNames() {
         '::1',
     ];
 }
-async function defaultCertificateNeedsRefresh() {
-    if (!fileExists(defaultHttpsCertPath) || !fileExists(defaultHttpsKeyPath))
-        return true;
-    return (await getMissingCertificateNames(defaultHttpsCertPath, getRequiredLocalHttpsNames())).length > 0;
-}
 async function ensureDefaultHttpsCertificateFresh() {
-    if (!(await defaultCertificateNeedsRefresh()))
+    if (!localCertificateNeedsRefresh(certDir, getRequiredLocalHttpsNames()))
         return false;
-    console.log(`${ICON.info} ${c.dim('Local HTTPS certificate is missing current domain/IP SANs; regenerating...')}`);
-    await runSetupLocalHttps({ quietRestartHint: true, installCa: false });
+    console.log(`${ICON.info} ${c.dim('Local HTTPS certificate needs repair or renewal; preparing a validated replacement...')}`);
+    await runSetupLocalHttps({ quietRestartHint: true, installCa: false, allowCaChange: false });
     return true;
 }
 async function runSetupLocalHttps(options = {}) {
-    const mkcert = await ensureMkcertInstalled();
-    ensureStateDir();
-    fs.mkdirSync(certDir, { recursive: true, mode: 0o700 });
-    if (options.installCa !== false) {
-        console.log(`${ICON.info} ${c.dim('Installing local CA into this computer trust store...')}`);
-        await execFileAsync(mkcert, ['-install'], { timeout: 120000, maxBuffer: 1024 * 1024 });
-    }
-    console.log(`${ICON.info} ${c.dim('Generating local certificate for Termdock domains...')}`);
-    await execFileAsync(mkcert, [
-        '-cert-file', defaultHttpsCertPath,
-        '-key-file', defaultHttpsKeyPath,
-        ...getRequiredLocalHttpsNames(),
-    ], { cwd: certDir, timeout: 120000, maxBuffer: 1024 * 1024 });
-    try {
-        const { stdout } = await execFileAsync(mkcert, ['-CAROOT'], { timeout: 5000, maxBuffer: 64 * 1024 });
-        const rootCA = path.join(stdout.trim(), 'rootCA.pem');
-        if (fs.existsSync(rootCA)) {
-            fs.copyFileSync(rootCA, defaultHttpsCaPath);
-            try {
-                fs.chmodSync(defaultHttpsCaPath, 0o600);
-            }
-            catch { /* ignore */ }
-        }
-    }
-    catch { /* CA download is optional but recommended */ }
-    try {
-        fs.chmodSync(defaultHttpsCertPath, 0o600);
-    }
-    catch { /* ignore */ }
-    try {
-        fs.chmodSync(defaultHttpsKeyPath, 0o600);
-    }
-    catch { /* ignore */ }
-    console.log(`${ICON.ok} ${c.green('Local HTTPS certificates are ready.')}`);
-    console.log(`  ${c.dim('Cert:')} ${c.cyan(defaultHttpsCertPath)}`);
-    console.log(`  ${c.dim('Key:')}  ${c.cyan(defaultHttpsKeyPath)}`);
-    if (fs.existsSync(defaultHttpsCaPath)) {
-        console.log(`  ${c.dim('CA:')}   ${c.cyan(defaultHttpsCaPath)} ${c.dim('(served on mobile setup page)')}`);
-    }
+    const result = await setupLocalHttps({
+        directory: certDir, names: getRequiredLocalHttpsNames(),
+        installCa: options.installCa, allowCaChange: options.allowCaChange,
+        log: message => console.log(`${ICON.info} ${c.dim(message)}`),
+    });
+    console.log(`${ICON.ok} ${c.green('Local HTTPS certificates are generated and validated.')}`);
+    console.log(`  ${c.dim('Cert:')} ${c.cyan(result.files.cert)}`);
+    console.log(`  ${c.dim('Key:')}  ${c.cyan(result.files.key)}`);
+    console.log(`  ${c.dim('CA:')}   ${c.cyan(result.files.ca)} ${c.dim('(install and trust this public certificate on each client device)')}`);
+    for (const warning of result.warnings)
+        console.warn(`${ICON.warn} ${c.yellow(warning)}`);
+    if (result.trust === 'requested')
+        console.log(`  ${c.dim('Local CA trust installation was requested; browser trust may require certutil and a browser restart.')}`);
+    else
+        console.log(`  ${c.dim('Local CA trust has not been installed by this command.')}`);
     console.log('');
-    if (!options.quietRestartHint) {
+    if (!options.quietRestartHint)
         console.log(`${ICON.info} ${c.dim('Restart Termdock to use HTTPS:')} ${c.cyan('td --stop && td')}`);
-    }
 }
 function printRunningState(state) {
     const displayHost = state.host === '0.0.0.0' ? 'localhost' : state.host;
@@ -632,6 +555,7 @@ function parseArgs(argv) {
     let httpsKey;
     let httpsCa;
     let setupLocalHttps = false;
+    let installLocalCa = true;
     let foreground = false;
     let supervise = false;
     let noSupervisor = false;
@@ -931,6 +855,10 @@ function parseArgs(argv) {
             setupLocalHttps = true;
             continue;
         }
+        if (arg === '--no-install-ca') {
+            installLocalCa = false;
+            continue;
+        }
         if (arg === '--foreground') {
             foreground = true;
             continue;
@@ -1173,6 +1101,7 @@ function parseArgs(argv) {
         httpsKey,
         httpsCa,
         setupLocalHttps,
+        installLocalCa,
         foreground,
         supervise,
         noSupervisor,
@@ -2140,7 +2069,7 @@ function runPluginInitJson() {
             hooks: 'Hooks publish declared lifecycle/status events; collaboration does not wait for an idle phase and does not require hooks.',
         },
         security: {
-            source: 'Only public HTTPS repository roots on approved Git hosts or explicit local paths are accepted; URL credentials are rejected.',
+            source: 'Public and self-hosted Git repositories support HTTPS, HTTP, SSH and scp-style addresses. The service computer uses its Git credential helpers, SSH agent/configuration, proxy and CA settings. URL passwords and query tokens are rejected.',
             package: 'Symlinks, active/external SVG content, oversized files, submodules, and excessive unpacked size are rejected.',
             hooks: 'hooks.target must be a non-symlinked ~/ JSON path. Termdock generates the hook command; manifests cannot inject shell.',
             titleCommands: 'Installing or inspecting a plugin never executes its title/model commands. They run only after the user enables automatic titles for that plugin.',
@@ -2167,7 +2096,7 @@ function runPluginInitJson() {
         },
         integrationSteps: [
             'Create a repository with manifest.json at its root; icon.svg and helper files are optional.',
-            'Publish the repository, then install it with td plugin-install <https-git-url>. Local directories are also supported.',
+            'Publish the repository, then install it with td plugin-install <git-url>. Public/private HTTPS, HTTP, SSH and local directories are supported.',
             'For manifest-only development, td plugin-create <manifest-file> remains available.',
             'Ask the user to open Settings > Detection Rules and click Install for this Agent. They can uninstall it there later.',
             'If the Agent hook format is not a Claude-style hooks map, configure native hooks to call td agent-event directly.',
@@ -2318,7 +2247,7 @@ ${c.dim('──────────────────')}
   ${c.dim('# Inject the Agent definition; it appears in the UI immediately')}
   td plugin-create ./trae-manifest.json
 
-  ${c.dim('# Or install a complete, updateable package from a public HTTPS Git repository')}
+  ${c.dim('# Or install a complete, updateable package from a public or private Git repository')}
   td plugin-install https://github.com/owner/trae-termdock-plugin
 
   ${c.dim('# The user then opens Settings > Detection Rules and clicks Install.')}
@@ -3360,7 +3289,7 @@ async function promptLine(prompt) {
     });
 }
 async function runFirstRunWizard() {
-    if (!process.stdin.isTTY || isFirstRunCompleted())
+    if (!process.stdin.isTTY || !process.stdout.isTTY || isFirstRunCompleted())
         return;
     console.log(`${ICON.info} ${c.bold('Termdock first-time local access setup')}`);
     const prefix = await promptLine('  Choose your .termdock.local prefix (e.g. jovn): ');
@@ -3411,12 +3340,18 @@ async function waitForServerMetadata(result, fallbackPort) {
     };
 }
 async function refreshDefaultHttpsCertificateSafely() {
+    // Explicit custom certificates belong to their operator. A declined setup or
+    // headless first run without any default files must not trigger a download.
+    const custom = options.httpsCert && options.httpsCert !== defaultHttpsCertPath
+        || options.httpsKey && options.httpsKey !== defaultHttpsKeyPath
+        || options.httpsCa && options.httpsCa !== defaultHttpsCaPath;
+    if (custom || ![defaultHttpsCertPath, defaultHttpsKeyPath, defaultHttpsCaPath].some(file => fs.existsSync(file)))
+        return false;
     try {
         return await ensureDefaultHttpsCertificateFresh();
     }
     catch (error) {
-        console.error(error instanceof Error ? error.message : error);
-        return false;
+        throw new Error(`Existing local HTTPS configuration could not be repaired; refusing to fall back to HTTP. Run td --setup-local-https. ${String(error)}`, { cause: error });
     }
 }
 async function main() {
@@ -3445,7 +3380,7 @@ async function main() {
     }
     if (options.setupLocalHttps) {
         try {
-            await runSetupLocalHttps();
+            await runSetupLocalHttps({ installCa: options.installLocalCa });
             process.exit(0);
         }
         catch (error) {
@@ -3570,7 +3505,7 @@ async function main() {
     }
     if (options.pluginInstall !== undefined) {
         if (!options.pluginInstall) {
-            console.error(`${ICON.err} ${c.red('plugin-install requires an HTTPS Git URL or local package path')}`);
+            console.error(`${ICON.err} ${c.red('plugin-install requires a Git URL (HTTPS/HTTP/SSH) or local package path')}`);
             process.exit(1);
         }
         await runPluginInstall(options.pluginInstall);
@@ -3753,8 +3688,13 @@ async function main() {
         return;
     }
     if (options.foreground) {
-        // Boot check (marker prevents re-run if parent already completed)
-        runBootChecks();
+        const bootChecks = runBootChecks();
+        if (!bootChecks.nodePty.ok || !bootChecks.tmux.ok) {
+            for (const line of formatBootCheckReport(bootChecks, colorsEnabled))
+                console.log(line);
+        }
+        if (!bootChecks.nodePty.ok)
+            throw new Error('Native terminal initialization failed; see the boot check above.');
         warnIfAuthDisabled(options.host ?? DEFAULT_HOST);
         // Dynamic import keeps terminal.ts side-effects (loadClientStatesFromDisk
         // etc.) out of fast paths like `termdock --tls` / `--status`.
@@ -3879,6 +3819,8 @@ async function main() {
         }
         console.log("");
     }
+    if (!bootChecks.nodePty.ok)
+        process.exit(1);
     await runFirstRunWizard();
     await refreshDefaultHttpsCertificateSafely();
     const refreshedHttps = resolveHttpsOptions(options);

package/dist/server/entry.js

@@ -5,7 +5,7 @@ import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/col
 import { collaborationStore, collaborationTaskStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions, prepareCollaborationTaskWorker, integrationSessionAdapter } from './routes/terminal.js';
 import { CollaborationTaskService } from './agent/collaborationTaskService.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
-import { desktopDirectTargets } from './federation/desktopTargets.js';
+import { desktopServiceTargets } from './federation/desktopTargets.js';
 import { createOpenAccessRouter } from './federation/openAccess.js';
 import { createPasswordLoginRouter } from './federation/passwordLoginRoutes.js';
 import { apiAccessGate, isTrustedLocalRequest } from './utils/apiAccess.js';
@@ -14,7 +14,8 @@ import { createFederationRuntime } from './federation/runtime.js';
 import { startWebTransportServer } from './federation/webTransportServer.js';
 import { RouteAccess } from './federation/routeAccess.js';
 import { RouteInvitationStore } from './federation/routeInvitations.js';
-import { attachRegisteredDirectTargets, verifyDirectTarget } from './federation/directRoutes.js';
+import { verifyDirectTarget } from './federation/directRoutes.js';
+import { DirectTargetRegistry } from './federation/directTargetRegistry.js';
 import { secureChannelOriginAllowed } from './federation/originPolicy.js';
 import { RelayRouter } from './federation/relay.js';
 import { DesktopSelfRelay } from './federation/selfRelay.js';
@@ -490,7 +491,7 @@ export function startServer(options = {}) {
     let routeInvitations;
     let federationServiceId = '';
     let activeRouteIds = () => [];
-    const desktopTargets = () => desktopDirectTargets(path.join(homedir(), '.termdock', 'desktop.json'), federationServiceId);
+    const desktopTargets = () => desktopServiceTargets(homedir(), federationServiceId);
     const routeAccess = new RouteAccess(path.join(homedir(), '.termdock', 'federation', 'routes.json'), Date.now, (subjectId, targetServiceId) => routeInvitations?.allows(subjectId, targetServiceId) === true || collaborationTransport?.canRoute(subjectId, targetServiceId) === true, desktopTargets, () => activeRouteIds());
     const relayRouter = new RelayRouter({
         isLocalTarget: id => id === federationServiceId,
@@ -499,29 +500,14 @@ export function startServer(options = {}) {
         allowRoute: (principal, serviceId) => routeAccess.allowRoute(principal, serviceId),
     });
     activeRouteIds = () => relayRouter.activeRouteIds();
-    const dynamicDirectTargets = new Map();
+    const directTargetRegistry = new DirectTargetRegistry(relayRouter, path.join(homedir(), '.termdock', 'federation'));
     const refreshDirectTargets = () => {
-        const desired = new Map(routeAccess.configuredDirectTargets().filter(target => target.serviceId !== federationServiceId).map(target => [target.serviceId, target]));
-        for (const [id, registered] of dynamicDirectTargets) {
-            const target = desired.get(id);
-            if (!target || registered.signature !== JSON.stringify([target.url, target.caPath, target.caFingerprint256])) {
-                registered.close();
-                dynamicDirectTargets.delete(id);
-            }
-        }
-        for (const [id, target] of desired)
-            if (!dynamicDirectTargets.has(id)) {
-                try {
-                    dynamicDirectTargets.set(id, { signature: JSON.stringify([target.url, target.caPath, target.caFingerprint256]), close: attachRegisteredDirectTargets(relayRouter, [target], path.join(homedir(), '.termdock', 'federation')) });
-                }
-                catch { /* A malformed or unavailable local route remains unusable. */ }
-            }
+        directTargetRegistry.refresh(routeAccess.configuredDirectTargets().filter(target => target.serviceId !== federationServiceId));
     };
     refreshDirectTargets();
     const desktopRoutesTimer = setInterval(refreshDirectTargets, 2000);
     desktopRoutesTimer.unref();
-    onServerClose(() => { clearInterval(desktopRoutesTimer); for (const target of dynamicDirectTargets.values())
-        target.close(); });
+    onServerClose(() => { clearInterval(desktopRoutesTimer); directTargetRegistry.close(); });
     onServerClose(() => relayRouter.close());
     onServerClose(() => { void stopAllScrcpySessions(); void androidRecordings.stopAll(); });
     onServerClose(stopComputerBridges);
@@ -559,7 +545,10 @@ export function startServer(options = {}) {
                 throw new Error('COLLABORATION_UNAVAILABLE');
             return collaborationTransport.receive(subjectId, packet);
         },
-        listRouteTargets: () => { refreshDirectTargets(); return routeAccess.configuredTargets().map(target => ({ ...target, available: relayRouter.hasRoute(target.serviceId) })); },
+        listRouteTargets: () => {
+            refreshDirectTargets();
+            return routeAccess.configuredTargets().map(target => directTargetRegistry.describe(target));
+        },
         listRouteAccess: () => routeInvitations?.list() || [],
         grantRouteAccess: async (issuerId, targetServiceId, subjectId, url) => {
             if (!routeInvitations)
@@ -693,7 +682,12 @@ export function startServer(options = {}) {
         const selfRelay = new DesktopSelfRelay({
             desktopFile: path.join(homedir(), '.termdock', 'desktop.json'),
             targets: () => routeAccess.configuredDirectTargets(), baseDir: path.join(homedir(), '.termdock', 'federation'), identity: runtime.identity, serviceId: runtime.serviceId,
-            localOrigin: `${scheme}://${localAuthority}:${port}`, ...(localCa ? { localCa } : {}),
+            localOrigin: () => {
+                const address = server.address();
+                if (!address || typeof address === 'string')
+                    throw new Error('Local service is not listening');
+                return `${scheme}://${localAuthority}:${address.port}`;
+            }, ...(localCa ? { localCa } : {}),
         });
         selfRelay.start();
         onServerClose(() => selfRelay.close());