zerogterm 0.9.0-alpha.1 → 0.9.2-alpha.1

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('/'))