zerogterm 0.9.1-alpha.1 → 0.9.2-alpha.1

package/dist/main/main/pane-link.js

@@ -0,0 +1,335 @@
+// Pane link: relay one agent's finished reply into another agent's prompt.
+//
+// This module is the decision logic only. It owns no sockets and no PTYs: the hook
+// server feeds it what the agents report (a prompt was submitted, a turn finished, the
+// agent needs attention, the session ended) and it answers by asking for text to be
+// delivered to a session. Keeping it that small is what lets every safety rule below be
+// exercised in a unit test with a fake clock.
+//
+// Why hook events and not terminal output: a throwaway prototype that guessed turn ends
+// from a quiet timer and scraped the reply off the screen declared turns finished while
+// the agent was still thinking and forwarded spinner glyphs and echoed prompts. The Stop
+// hook reports the turn end exactly and carries the final message verbatim.
+//
+// Safety rules enforced here (CONTEXT.md: no autonomous agent loops without an explicit
+// design):
+//  - A link exists only because the user asked for it, between two agents ZeroG itself
+//    launched, and it ends on the user's say-so, on the turn cap, or when either agent exits.
+//  - Text is only delivered to an agent that is idle. If the partner is busy the link
+//    pauses and holds the message; it never types into a running turn.
+//  - Relayed text is untrusted input to the receiving agent. It is stripped of control
+//    characters (an ESC would let a reply close the bracketed paste early and have the rest
+//    typed as keystrokes), size-capped, and labelled as coming from another agent.
+//  - A relay that never gets an answer (permission prompt left open, Esc interrupt, API
+//    error: none of which fire Stop) pauses after a stall timeout instead of waiting forever.
+export const DEFAULT_RELAY_CAP = 6;
+export const MAX_RELAY_CAP = 50;
+export const DEFAULT_STALL_MS = 10 * 60 * 1000;
+export const MAX_RELAY_CHARS = 16000;
+const TRUNCATION_NOTE = '\n[Truncated by ZeroG pane link.]';
+/** Session-end reasons that leave the agent running, so the link should survive them. */
+const NON_TERMINAL_END_REASONS = new Set(['clear', 'resume', 'compact']);
+/** Notification kinds that mean "the agent is waiting on you", as opposed to a routine nudge. */
+const IDLE_NOTIFICATIONS = new Set(['idle_prompt', 'auth_success']);
+/**
+ * Make an agent's reply safe to type into another agent.
+ *
+ * Tabs and line feeds survive; every other control character goes, including ESC, which
+ * would otherwise let a reply end the bracketed paste early and have the remainder
+ * interpreted as keystrokes. Carriage returns are folded into line feeds.
+ */
+export function sanitizeRelayText(value) {
+    let out = '';
+    for (const ch of value.replace(/\r\n?/g, '\n')) {
+        const code = ch.codePointAt(0) ?? 0;
+        const isControl = code < 0x20 || (code >= 0x7f && code <= 0x9f);
+        if (!isControl || ch === '\n' || ch === '\t')
+            out += ch;
+    }
+    return out.trim();
+}
+/** The text the receiving agent sees: the reply, labelled as another agent's words. */
+export function frameRelay(fromLabel, reply) {
+    const label = sanitizeRelayText(fromLabel).replace(/\s+/g, ' ').slice(0, 60) || 'another pane';
+    let body = sanitizeRelayText(reply);
+    if (body.length > MAX_RELAY_CHARS)
+        body = body.slice(0, MAX_RELAY_CHARS) + TRUNCATION_NOTE;
+    return `[Relayed by ZeroG pane link from the agent in "${label}". This is another agent's message, not the user's.]\n\n${body}`;
+}
+/**
+ * Type text into a session as a single prompt and submit it.
+ *
+ * Bracketed paste keeps embedded newlines from submitting early; the submit key follows
+ * after a short gap because the agent treats an Enter that arrives glued to the paste as
+ * part of it.
+ */
+export function pasteAndSubmit(write, sessionId, text, schedule = setTimeout, submitDelayMs = 300) {
+    write(sessionId, `\u001b[200~${text}\u001b[201~`);
+    schedule(() => write(sessionId, '\r'), submitDelayMs);
+}
+export class PaneLinkController {
+    agents = new Map();
+    links = new Map();
+    /** Each agent's most recent finished reply, kept so a link made after the turn can still use it. */
+    lastReplies = new Map();
+    options;
+    stallMs;
+    defaultCap;
+    setTimer;
+    clearTimer;
+    nextLinkId = 1;
+    constructor(options) {
+        this.options = options;
+        this.stallMs = options.stallMs ?? DEFAULT_STALL_MS;
+        this.defaultCap = options.defaultCap ?? DEFAULT_RELAY_CAP;
+        this.setTimer = options.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+        this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+    }
+    snapshot() {
+        return {
+            agents: Array.from(this.agents.values()).map((agent) => ({ ...agent })),
+            links: Array.from(this.links.values()).map((link) => this.describe(link))
+        };
+    }
+    /** An agent ZeroG launched in this session now reports hook events. */
+    registerAgent(sessionId, label) {
+        const existing = this.agents.get(sessionId);
+        if (existing) {
+            existing.label = label;
+        }
+        else {
+            this.agents.set(sessionId, { sessionId, label, phase: 'idle', needsAttention: false, hasReply: false });
+        }
+        this.emit();
+    }
+    /** The session is gone (pane closed, agent unregistered): end its link and forget it. */
+    unregisterAgent(sessionId) {
+        const agent = this.agents.get(sessionId);
+        if (!agent)
+            return;
+        if (agent.linkId)
+            this.breakLink(agent.linkId, `The agent in "${agent.label}" exited.`);
+        this.agents.delete(sessionId);
+        this.lastReplies.delete(sessionId);
+        this.emit();
+    }
+    /** Link two idle agents. Throws a user-readable message when the link is not allowed. */
+    link(aSessionId, bSessionId, cap) {
+        if (aSessionId === bSessionId)
+            throw new Error('Choose two different panes to link.');
+        const a = this.agents.get(aSessionId);
+        const b = this.agents.get(bSessionId);
+        if (!a || !b)
+            throw new Error('Both panes must be running an agent started with "Start linked agent".');
+        if (a.linkId || b.linkId)
+            throw new Error('A pane can only be in one link at a time. Break the existing link first.');
+        if (a.phase !== 'idle' || b.phase !== 'idle')
+            throw new Error('Wait for both agents to finish their current turn before linking.');
+        // A broken link stays listed so its reason can be read; starting a new one retires it.
+        for (const stale of Array.from(this.links.values())) {
+            if (stale.status === 'broken' && [stale.a, stale.b].some((id) => id === aSessionId || id === bSessionId))
+                this.links.delete(stale.id);
+        }
+        const relays = cap ?? this.defaultCap;
+        if (!Number.isInteger(relays) || relays < 1 || relays > MAX_RELAY_CAP) {
+            throw new Error(`The relay limit must be a whole number from 1 to ${MAX_RELAY_CAP}.`);
+        }
+        const link = { id: `link-${this.nextLinkId++}`, a: aSessionId, b: bSessionId, status: 'active', turns: 0, cap: relays };
+        this.links.set(link.id, link);
+        a.linkId = link.id;
+        b.linkId = link.id;
+        this.emit();
+        return this.describe(link);
+    }
+    /** The user breaks the link. Removes it entirely. */
+    unlink(linkId) {
+        const link = this.links.get(linkId);
+        if (!link)
+            return;
+        this.dropLink(link);
+        this.emit();
+    }
+    /** Re-arm a paused link, delivering the held reply if there is one and the partner is ready. */
+    resume(linkId) {
+        const link = this.links.get(linkId);
+        if (!link)
+            throw new Error('That link no longer exists.');
+        if (link.status !== 'paused')
+            return this.describe(link);
+        const held = link.held;
+        link.status = 'active';
+        link.reason = undefined;
+        link.waitingOn = undefined;
+        if (held) {
+            link.held = undefined;
+            this.relay(link, held.from, held.text);
+        }
+        this.emit();
+        return this.describe(link);
+    }
+    /**
+     * Relay an agent's most recent reply now. For a link made after the agent's turn
+     * finished (nothing else would ever trigger it) and for resuming by hand.
+     */
+    relayLast(linkId, fromSessionId) {
+        const link = this.links.get(linkId);
+        if (!link)
+            throw new Error('That link no longer exists.');
+        if (link.status === 'broken')
+            throw new Error('That link has ended. Link the panes again first.');
+        if (fromSessionId !== link.a && fromSessionId !== link.b)
+            throw new Error('That pane is not part of this link.');
+        const reply = this.lastReplies.get(fromSessionId);
+        if (!reply)
+            throw new Error('That agent has not finished a reply yet.');
+        if (link.waitingOn)
+            throw new Error('Wait for the agent that is already working on a relayed message.');
+        link.status = 'active';
+        link.reason = undefined;
+        link.held = undefined;
+        this.relay(link, fromSessionId, reply);
+        this.emit();
+        return this.describe(link);
+    }
+    /** Feed an event reported by an agent's hooks. */
+    handle(event) {
+        const agent = this.agents.get(event.sessionId);
+        if (!agent)
+            return;
+        const link = agent.linkId ? this.links.get(agent.linkId) : undefined;
+        switch (event.event) {
+            case 'UserPromptSubmit':
+                agent.phase = 'busy';
+                agent.needsAttention = false;
+                break;
+            case 'Notification':
+                if (!IDLE_NOTIFICATIONS.has(event.notificationType ?? ''))
+                    agent.needsAttention = true;
+                break;
+            case 'SessionEnd':
+                if (NON_TERMINAL_END_REASONS.has(event.reason ?? ''))
+                    break;
+                if (link)
+                    this.breakLink(link.id, `The agent in "${agent.label}" exited.`);
+                this.agents.delete(agent.sessionId);
+                break;
+            case 'Stop':
+                agent.phase = 'idle';
+                agent.needsAttention = false;
+                if (sanitizeRelayText(event.message ?? '')) {
+                    this.lastReplies.set(agent.sessionId, event.message ?? '');
+                    agent.hasReply = true;
+                }
+                if (link)
+                    this.onTurnFinished(link, agent, event.message ?? '');
+                break;
+        }
+        this.emit();
+    }
+    onTurnFinished(link, agent, message) {
+        if (link.status !== 'active')
+            return;
+        // We are waiting on the other agent, so this turn is not one we should relay (the user
+        // is driving this pane by hand). The expected answer will still arrive from the other side.
+        if (link.waitingOn && link.waitingOn !== agent.sessionId)
+            return;
+        this.cancelStall(link);
+        link.waitingOn = undefined;
+        if (!sanitizeRelayText(message)) {
+            this.pause(link, `The agent in "${agent.label}" finished without a reply to relay.`);
+            return;
+        }
+        if (link.turns >= link.cap) {
+            this.breakLink(link.id, `Reached the limit of ${link.cap} relays.`);
+            return;
+        }
+        this.relay(link, agent.sessionId, message);
+    }
+    relay(link, fromSessionId, message) {
+        const from = this.agents.get(fromSessionId);
+        const toSessionId = link.a === fromSessionId ? link.b : link.a;
+        const to = this.agents.get(toSessionId);
+        if (!from || !to) {
+            this.breakLink(link.id, 'One of the linked agents is gone.');
+            return;
+        }
+        if (link.turns >= link.cap) {
+            this.breakLink(link.id, `Reached the limit of ${link.cap} relays.`);
+            return;
+        }
+        if (to.phase !== 'idle' || to.needsAttention) {
+            link.held = { from: fromSessionId, text: message };
+            this.pause(link, to.needsAttention
+                ? `The agent in "${to.label}" is waiting for you. Answer it, then resume.`
+                : `The agent in "${to.label}" is busy. Resume once it finishes.`);
+            return;
+        }
+        to.phase = 'busy';
+        link.turns += 1;
+        link.waitingOn = toSessionId;
+        this.options.deliver(toSessionId, frameRelay(from.label, message));
+        this.armStall(link, to.label);
+    }
+    pause(link, reason) {
+        this.cancelStall(link);
+        link.status = 'paused';
+        link.reason = reason;
+    }
+    breakLink(linkId, reason) {
+        const link = this.links.get(linkId);
+        if (!link)
+            return;
+        this.cancelStall(link);
+        link.status = 'broken';
+        link.reason = reason;
+        link.waitingOn = undefined;
+        link.held = undefined;
+        for (const sessionId of [link.a, link.b]) {
+            const agent = this.agents.get(sessionId);
+            if (agent?.linkId === link.id)
+                agent.linkId = undefined;
+        }
+        // A broken link stays listed so the user can read why it ended; it no longer holds either pane.
+    }
+    dropLink(link) {
+        this.cancelStall(link);
+        for (const sessionId of [link.a, link.b]) {
+            const agent = this.agents.get(sessionId);
+            if (agent?.linkId === link.id)
+                agent.linkId = undefined;
+        }
+        this.links.delete(link.id);
+    }
+    armStall(link, waitingLabel) {
+        this.cancelStall(link);
+        link.stallTimer = this.setTimer(() => {
+            link.stallTimer = undefined;
+            if (link.status !== 'active')
+                return;
+            this.pause(link, `No reply from "${waitingLabel}". It may be waiting for approval or was interrupted.`);
+            this.emit();
+        }, this.stallMs);
+    }
+    cancelStall(link) {
+        if (link.stallTimer !== undefined) {
+            this.clearTimer(link.stallTimer);
+            link.stallTimer = undefined;
+        }
+    }
+    describe(link) {
+        return {
+            id: link.id,
+            a: link.a,
+            b: link.b,
+            status: link.status,
+            turns: link.turns,
+            cap: link.cap,
+            reason: link.reason,
+            waitingOn: link.waitingOn,
+            holding: link.held !== undefined
+        };
+    }
+    emit() {
+        this.options.onChange?.(this.snapshot());
+    }
+}

package/dist/main/main/preload.cjs

@@ -14,6 +14,8 @@ const api = {
   answerForwardPrompt: (id, answer) => ipcRenderer.invoke('forwards:answerPrompt', id, answer),
   loadForwards: () => ipcRenderer.invoke('forwards:load'),
   saveForwards: (file) => ipcRenderer.invoke('forwards:save', file),
+  loadHostLabels: () => ipcRenderer.invoke('hostLabels:load'),
+  saveHostLabels: (file) => ipcRenderer.invoke('hostLabels:save', file),
   onForwardEvent: (callback) => {
     const listener = (_event, payload) => callback(payload);
     ipcRenderer.on('forwards:event', listener);
@@ -49,6 +51,17 @@ const api = {
     ipcRenderer.on('mcp:execution', listener);
     return () => ipcRenderer.removeListener('mcp:execution', listener);
   },
+  launchLinkedAgent: (sessionId, agentCommand) => ipcRenderer.invoke('paneLinks:launchAgent', sessionId, agentCommand),
+  listPaneLinks: () => ipcRenderer.invoke('paneLinks:list'),
+  linkPanes: (a, b, cap) => ipcRenderer.invoke('paneLinks:link', a, b, cap),
+  relayLastReply: (linkId, fromSessionId) => ipcRenderer.invoke('paneLinks:relayLast', linkId, fromSessionId),
+  unlinkPanes: (linkId) => ipcRenderer.invoke('paneLinks:unlink', linkId),
+  resumePaneLink: (linkId) => ipcRenderer.invoke('paneLinks:resume', linkId),
+  onPaneLinks: (callback) => {
+    const listener = (_event, snapshot) => callback(snapshot);
+    ipcRenderer.on('paneLinks:changed', listener);
+    return () => ipcRenderer.removeListener('paneLinks:changed', listener);
+  },
   listBackends: () => ipcRenderer.invoke('sessions:backends'),
   listWslDistributions: () => ipcRenderer.invoke('sessions:wslDistributions'),
   createLocalSession: (request) => ipcRenderer.invoke('sessions:createLocal', request),
@@ -86,6 +99,8 @@ const api = {
   createLocalDirectory: (path) => ipcRenderer.invoke('fs:mkdirLocal', path),
   renameLocalEntry: (from, to) => ipcRenderer.invoke('fs:renameLocal', from, to),
   removeLocalEntry: (path, kind) => ipcRenderer.invoke('fs:removeLocal', path, kind),
+  readLocalFile: (path) => ipcRenderer.invoke('fs:readLocalFile', path),
+  writeLocalFile: (path, text, expectedMtimeMs, overwrite) => ipcRenderer.invoke('fs:writeLocalFile', path, text, expectedMtimeMs, overwrite),
   sftpOpen: (target, cwd) => ipcRenderer.invoke('sftp:open', target, cwd),
   sftpList: (sessionId, path) => ipcRenderer.invoke('sftp:list', sessionId, path),
   sftpMkdir: (sessionId, path) => ipcRenderer.invoke('sftp:mkdir', sessionId, path),
@@ -94,6 +109,8 @@ const api = {
   sftpUpload: (sessionId, localPath, remoteDir) => ipcRenderer.invoke('sftp:upload', sessionId, localPath, remoteDir),
   sftpDownload: (sessionId, remotePath, localDir, kind) => ipcRenderer.invoke('sftp:download', sessionId, remotePath, localDir, kind),
   sftpAnswerPrompt: (sessionId, answer) => ipcRenderer.invoke('sftp:answerPrompt', sessionId, answer),
+  sftpReadFile: (sessionId, path) => ipcRenderer.invoke('sftp:readFile', sessionId, path),
+  sftpWriteFile: (sessionId, path, text, opened, overwrite) => ipcRenderer.invoke('sftp:writeFile', sessionId, path, text, opened, overwrite),
   sftpClose: (sessionId) => ipcRenderer.invoke('sftp:close', sessionId),
   onSftpEvent: (callback) => {
     const listener = (_event, payload) => callback(payload);

package/dist/main/main/remote-file.js

@@ -0,0 +1,97 @@
+// Reading and writing one text file on an SSH host, for the editor.
+//
+// sftp has no "send me the bytes" command, only get and put, so a read is a
+// download to a private temp directory and a save is an upload from one. Each is
+// cleaned up whatever happens: a copy of someone's `.env` left in a temp folder
+// is the worst thing this module could do.
+//
+// A save is checked against the host the same way a local one is checked against
+// the disk, but by *content*: sftp's listing times are only minute-accurate, so
+// the file is fetched again and compared with what the editor opened. That costs
+// a second transfer and cannot be wrong.
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { EDIT_CONFLICT_MESSAGE, MAX_EDIT_BYTES } from '../shared/editing.js';
+import { baseName, parentRemote } from '../shared/files.js';
+import { checkEditableSize, decodeEditable, megabytes } from './editable.js';
+import { isSafeRemotePath } from './sftp-protocol.js';
+async function withTempDir(run) {
+    // mkdtemp makes the directory private to this user where the platform has
+    // such a thing.
+    const dir = await mkdtemp(join(tmpdir(), 'zerog-remote-edit-'));
+    try {
+        return await run(dir);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+function requireEditablePath(path) {
+    if (!path.startsWith('/'))
+        throw new Error('Only absolute remote paths can be edited.');
+    if (!isSafeRemotePath(path)) {
+        throw new Error('That file name has a quote, backslash, wildcard or control character in it, which this editor cannot open over SSH yet.');
+    }
+}
+/** The file's bytes, fetched into a temp directory and read back out of it. */
+async function fetch(transport, sessionId, path) {
+    return withTempDir(async (dir) => {
+        await transport.download(sessionId, path, dir, 'file');
+        const local = join(dir, baseName(path));
+        const info = await stat(local);
+        // The listing could not vouch for the size of a symlink, so the real one is
+        // checked here too — after the fact, but before the bytes are read.
+        checkEditableSize(info.size);
+        return readFile(local);
+    });
+}
+/**
+ * Read a remote file as text, or say why it cannot be edited.
+ *
+ * The size is taken from a listing first, so a large file is refused before it
+ * is downloaded rather than after.
+ */
+export async function readRemoteFile(transport, sessionId, path) {
+    requireEditablePath(path);
+    const listing = await transport.list(sessionId, parentRemote(path));
+    const entry = listing.entries.find((candidate) => candidate.name === baseName(path));
+    if (!entry)
+        throw new Error('That file does not exist on the host.');
+    if (entry.kind === 'directory')
+        throw new Error('That is not a file.');
+    // A symlink's listed size is the link's own, so it is checked after the fetch.
+    if (entry.kind === 'file')
+        checkEditableSize(entry.size);
+    const bytes = await fetch(transport, sessionId, path);
+    return { path, text: decodeEditable(bytes), size: bytes.length };
+}
+/**
+ * Save the editor's text to a remote file.
+ *
+ * `opened` is the exact text the editor read, and the save is refused if the host
+ * now holds something else. `overwrite` is the user saying they have seen that.
+ *
+ * The upload is a plain `put` with no `-p`: that leaves an existing file's
+ * permissions alone, where preserving the temp file's would reset them — a
+ * `.env` that was 600 must not come back world-readable.
+ */
+export async function writeRemoteFile(transport, sessionId, path, text, opened, overwrite = false) {
+    requireEditablePath(path);
+    if (Buffer.byteLength(text, 'utf8') > MAX_EDIT_BYTES) {
+        throw new Error(`That is more than ${megabytes(MAX_EDIT_BYTES)}, which is more than the editor saves.`);
+    }
+    if (!overwrite) {
+        // Not the same failure as "changed": a file that has gone is reported as
+        // gone, by the transfer's own error, rather than as a conflict.
+        const now = decodeEditable(await fetch(transport, sessionId, path));
+        if (now !== opened)
+            throw new Error(EDIT_CONFLICT_MESSAGE);
+    }
+    await withTempDir(async (dir) => {
+        const local = join(dir, baseName(path));
+        await writeFile(local, text, 'utf8');
+        await transport.putFile(sessionId, local, path);
+    });
+    return { size: Buffer.byteLength(text, 'utf8') };
+}

package/dist/main/main/sftp-service.js

@@ -196,6 +196,18 @@ export class SftpService {
         const command = `put -p ${quoteLocalPath(localPath)} ${quoteRemotePath(destination)}`;
         await this.enqueue(connection, () => this.checked(connection, command, TRANSFER_IDLE_MS, true));
     }
+    /**
+     * Upload one file to an exact remote path.
+     *
+     * No `-p`, unlike upload(): that would stamp the remote file with the local
+     * file's permissions, and the editor's local file is a temp copy. Without it an
+     * existing remote file keeps its own mode — a 600 `.env` stays 600.
+     */
+    async putFile(sessionId, localPath, remotePath) {
+        const connection = this.get(sessionId);
+        const command = `put ${quoteLocalPath(localPath)} ${quoteRemotePath(remotePath)}`;
+        await this.enqueue(connection, () => this.checked(connection, command, TRANSFER_IDLE_MS, true));
+    }
     async download(sessionId, remotePath, localDir, kind) {
         const connection = this.get(sessionId);
         const name = baseName(remotePath);

package/dist/main/main/workspace-store.js

@@ -129,6 +129,13 @@ function normalizeView(value, memberIds) {
     const browsers = normalizeBrowsers(item.browsers, memberIds);
     if (browsers)
         view.browsers = browsers;
+    // Slot order matters, so the list is kept as given, minus anything the
+    // workspace does not hold and any repeat.
+    const visible = Array.isArray(item.visiblePanes)
+        ? [...new Set(item.visiblePanes.map(member).filter((id) => id !== undefined))].slice(0, 2)
+        : [];
+    if (visible.length)
+        view.visiblePanes = visible;
     return view;
 }
 /**

package/dist/main/shared/editing.js

@@ -0,0 +1,11 @@
+// What the built-in editor and the main process both need to agree on.
+/** The largest file the editor will open or save. Past this it is not a text file to edit by hand. */
+export const MAX_EDIT_BYTES = 1024 * 1024;
+/**
+ * What a refused save says when the file changed after it was loaded.
+ *
+ * The renderer tells this apart from any other failure by the text, because an
+ * IPC rejection carries nothing but its message — and the two deserve different
+ * responses: a conflict offers to overwrite or reload, a failure just says so.
+ */
+export const EDIT_CONFLICT_MESSAGE = 'This file changed on disk after it was opened.';

package/dist/main/shared/files.js

@@ -11,6 +11,17 @@ export function sortEntries(entries) {
         return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
     });
 }
+/**
+ * Is this entry a dotfile?
+ *
+ * Neither backend reports a platform "hidden" attribute — the SFTP side is a
+ * parsed `ls` line, and Node's `fs.Stats` does not expose the Windows bit
+ * either — so the leading dot, the convention every listed shell already
+ * follows, is what "hidden" means here.
+ */
+export function isHiddenName(name) {
+    return name.startsWith('.');
+}
 /** Join a remote directory and a child name. Remote paths are always POSIX. */
 export function joinRemote(dir, name) {
     if (name.startsWith('/'))