@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/ssh-projects/gateway.js

@@ -0,0 +1,143 @@
+import { request } from "node:http";
+import { HttpError, readJson, send } from "../http.js";
+import { Previews } from "../preview.js";
+function parseRuntime(text) {
+  const raw = JSON.parse(text.split(/\r?\n/).reverse().find((line) => line.startsWith("CODEFLOW_SSH_READY "))?.slice(19) ?? "null");
+  if (raw?.protocol !== 1 || !Number.isInteger(raw.port) || raw.port < 1 || raw.port > 65535 || !/^[a-f0-9]{64}$/.test(raw.token) || !/^[a-f0-9]{32}$/.test(raw.instance) || !/^[a-f0-9]{64}$/.test(raw.version)) throw new Error("The SSH host returned an invalid backend handshake");
+  if (raw.remotePort !== void 0 && (!Number.isInteger(raw.remotePort) || raw.remotePort < 1 || raw.remotePort > 65535)) throw new Error("The SSH host returned an invalid team port");
+  return raw;
+}
+const HOP = /* @__PURE__ */ new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade"]);
+class SshGateway {
+  constructor(transport, runtime, reconnect, probe = "/api/ssh-runtime") {
+    this.transport = transport;
+    this.runtime = runtime;
+    this.reconnect = reconnect;
+    this.probe = probe;
+    this.previews = new Previews(() => [...this.origins], () => [this.runtime.port], (target) => this.open(target.port, target.hostname));
+  }
+  streams = /* @__PURE__ */ new Set();
+  origins = /* @__PURE__ */ new Set();
+  closed = false;
+  previews;
+  restoring;
+  error;
+  open(port, hostname) {
+    const stream = this.transport.open(port, hostname);
+    this.streams.add(stream);
+    stream.once("close", () => this.streams.delete(stream));
+    return stream;
+  }
+  restore() {
+    return this.restoring ??= (async () => {
+      const next = await this.reconnect();
+      if (this.closed) {
+        await next.transport.close();
+        throw new HttpError(410, "This computer was disconnected");
+      }
+      this.previews.closeAll();
+      for (const stream of this.streams) stream.destroy();
+      this.transport = next.transport;
+      this.runtime = next.runtime;
+      this.error = void 0;
+    })().finally(() => {
+      this.restoring = void 0;
+    });
+  }
+  async ensureConnected() {
+    if (this.restoring) return this.restoring;
+    const probedTransport = this.transport;
+    try {
+      await this.json(this.probe);
+    } catch {
+      if (this.transport === probedTransport) await this.restore();
+    }
+    if (this.restoring) await this.restoring;
+  }
+  async forward(req, res, path, origin, body) {
+    if (this.restoring) await this.restoring;
+    if (this.closed) throw new HttpError(410, "This computer was disconnected");
+    if (!path.startsWith("/api/")) throw new HttpError(404, "Unknown remote operation");
+    this.origins.add(origin);
+    res.setHeader("referrer-policy", "no-referrer");
+    res.setHeader("cache-control", "no-store");
+    if (new URL(path, origin).pathname === "/api/preview" && req.method === "POST") {
+      const lease = await this.json("/api/ssh-runtime/preview", "POST", await readJson(req, 8192));
+      return send(res, 200, await this.previews.show(String(lease.url), new URL(origin).host));
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) if (value !== void 0 && !HOP.has(key) && !["cookie", "authorization", "host", "origin", "referer", "forwarded"].includes(key) && !key.startsWith("x-forwarded-")) headers[key] = value;
+    headers.host = `127.0.0.1:${this.runtime.port}`;
+    headers.authorization = `Bearer ${this.runtime.token}`;
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    if (payload !== void 0) {
+      headers["content-type"] = "application/json";
+      headers["content-length"] = String(Buffer.byteLength(payload));
+    }
+    if (req.headers.origin) headers.origin = `http://${headers.host}`;
+    const up = request({ host: "127.0.0.1", port: this.runtime.port, method: req.method, path, headers, createConnection: () => this.open(this.runtime.port) }, (incoming) => {
+      this.error = void 0;
+      const out = {};
+      for (const [key, value] of Object.entries(incoming.headers)) if (value !== void 0 && !HOP.has(key) && !["set-cookie", "clear-site-data", "location", "content-security-policy", "content-security-policy-report-only"].includes(key)) out[key] = value;
+      if (incoming.headers.location) {
+        incoming.destroy();
+        send(res, 502, { error: "Unexpected remote API redirect" });
+        return;
+      }
+      out["content-security-policy"] = "sandbox allow-downloads; default-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'";
+      out["x-content-type-options"] = "nosniff";
+      out["referrer-policy"] = "no-referrer";
+      out["cache-control"] = "no-store";
+      res.writeHead(incoming.statusCode ?? 502, out);
+      incoming.pipe(res);
+      incoming.on("error", () => res.destroy());
+    });
+    up.on("error", () => {
+      if (res.destroyed) return;
+      this.error = "Connection interrupted. Reconnect this computer; your work remains there.";
+      if (res.headersSent) res.destroy();
+      else send(res, 502, { error: this.error });
+    });
+    res.on("close", () => {
+      if (!res.writableFinished) up.destroy();
+    });
+    if (payload !== void 0) up.end(payload);
+    else req.pipe(up);
+  }
+  json(path, method = "GET", body, timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      const payload = body === void 0 ? void 0 : JSON.stringify(body);
+      const req = request({ host: "127.0.0.1", port: this.runtime.port, method, path, headers: { authorization: `Bearer ${this.runtime.token}`, ...payload ? { "content-type": "application/json", "content-length": Buffer.byteLength(payload) } : {} }, createConnection: () => this.open(this.runtime.port) }, (res) => {
+        let text = "";
+        res.setEncoding("utf8");
+        res.on("data", (data) => {
+          text += data;
+          if (text.length > 2 * 1024 * 1024) req.destroy(new Error("Remote response exceeds its limit"));
+        });
+        res.on("error", reject);
+        res.on("end", () => {
+          try {
+            const value = JSON.parse(text);
+            if ((res.statusCode ?? 500) >= 400) reject(new HttpError(res.statusCode, value.error ?? "Remote request failed"));
+            else resolve(value);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+      const timer = setTimeout(() => req.destroy(new Error("Remote request timed out")), timeoutMs);
+      req.on("close", () => clearTimeout(timer));
+      req.on("error", reject);
+      req.end(payload);
+    });
+  }
+  async close() {
+    this.closed = true;
+    this.previews.closeAll();
+    for (const stream of this.streams) stream.destroy();
+  }
+}
+export {
+  SshGateway,
+  parseRuntime
+};

package/src/ssh-projects/manager.js

@@ -0,0 +1,320 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CODEFLOW_HOME } from "../config.js";
+import { HttpError, readJson } from "../http.js";
+import { sshAliases } from "./config.js";
+import { SshGateway, parseRuntime } from "./gateway.js";
+import { SshTransport, validSshHost, validSshOptions } from "./transport.js";
+class SshProjects {
+  constructor(options) {
+    this.options = options;
+    this.file = join(options.home ?? CODEFLOW_HOME, "ssh-hosts.json");
+  }
+  hosts = [];
+  loaded;
+  writes = Promise.resolve();
+  sessions = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  closed = false;
+  teamRemoving = /* @__PURE__ */ new Set();
+  teamSessions = /* @__PURE__ */ new Map();
+  teamPending = /* @__PURE__ */ new Map();
+  file;
+  load() {
+    return this.loaded ??= readFile(this.file, "utf8").then((text) => {
+      const raw = JSON.parse(text);
+      if (!raw || raw.version !== 1 || !Array.isArray(raw.hosts) || raw.hosts.length > 32 || raw.hosts.some((host) => !host || typeof host !== "object" || !/^[a-f0-9]{16}$/.test(host.id) || !validSshHost(host.sshHost) || !validSshOptions(host) || typeof host.name !== "string" || !host.name || host.name.length > 80) || new Set(raw.hosts.map((host) => host.id)).size !== raw.hosts.length) throw new Error("Repair the SSH connections file before continuing");
+      this.hosts = raw.hosts;
+    }).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
+  async list() {
+    await this.load();
+    return { hosts: this.hosts.map((host) => ({ ...host, state: this.pending.has(host.id) ? "connecting" : this.sessions.has(host.id) ? this.sessions.get(host.id).gateway.error ? "disconnected" : "connected" : "disconnected", error: this.sessions.get(host.id)?.gateway.error })), aliases: await sshAliases(this.options.configPath) };
+  }
+  change(operation) {
+    const work = this.writes.catch(() => void 0).then(async () => {
+      await this.load();
+      const before = this.hosts.slice();
+      operation();
+      try {
+        await mkdir(this.options.home ?? CODEFLOW_HOME, { recursive: true, mode: 448 });
+        const temp = `${this.file}.tmp`;
+        await writeFile(temp, JSON.stringify({ version: 1, hosts: this.hosts }), { mode: 384 });
+        await rename(temp, this.file);
+      } catch (error) {
+        this.hosts = before;
+        throw error;
+      }
+    });
+    this.writes = work;
+    return work;
+  }
+  async add(body) {
+    if (!validSshHost(body.sshHost)) throw new HttpError(400, "Enter an SSH alias or user@hostname.");
+    if (!validSshOptions(body)) throw new HttpError(400, "Use a port from 1 to 65535 and an absolute or ~/ SSH key path without control characters or % tokens");
+    const name = typeof body.name === "string" ? body.name.trim() : body.sshHost;
+    if (!name || name.length > 80) throw new HttpError(400, "Name the server using at most 80 characters");
+    const host = { id: randomBytes(8).toString("hex"), name, sshHost: body.sshHost, ...body.port === void 0 ? {} : { port: body.port }, ...body.identityFile === void 0 ? {} : { identityFile: body.identityFile } };
+    await this.change(() => {
+      if (this.hosts.length >= 32) throw new HttpError(409, "Remove an unused SSH connection first (32 maximum)");
+      if (this.hosts.some((item) => item.sshHost === host.sshHost && item.port === host.port && item.identityFile === host.identityFile)) throw new HttpError(409, "This SSH host is already saved");
+      this.hosts.push(host);
+    });
+    return host;
+  }
+  async setup(host, remotePort) {
+    const [code, payload] = await Promise.all([readFile(new URL("./bootstrap.mjs", import.meta.url), "utf8"), readFile(this.options.packagePath ?? fileURLToPath(new URL("../../dist/remote-host.json", import.meta.url)), "utf8").catch(() => {
+      throw new Error("Build the SSH host package with npm run build:host, then connect again.");
+    })]);
+    if (payload.length > 32 * 1024 * 1024) throw new Error("Remote host package exceeds 32 MiB");
+    const transport = new SshTransport(host.sshHost, this.options.sshBinary, host);
+    await transport.init();
+    try {
+      const runtime = parseRuntime(await transport.bootstrap(code, remotePort === void 0 ? payload : JSON.stringify({ ...JSON.parse(payload), remotePort, serviceBootstrap: code }), remotePort !== void 0));
+      return { transport, runtime, currentVersion: runtime.version === JSON.parse(payload).version };
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
+  }
+  async connect(id) {
+    await this.load();
+    if (this.closed) throw new HttpError(503, "The local app is shutting down");
+    const host = this.hosts.find((item) => item.id === id);
+    if (!host) throw new HttpError(404, "SSH connection not found");
+    let session = this.sessions.get(id);
+    if (session) await session.gateway.ensureConnected();
+    if (!session) {
+      let pending = this.pending.get(id);
+      if (!pending) {
+        if (this.sessions.size + this.pending.size >= 8) throw new HttpError(409, "Disconnect an unused server first (8 active connections maximum)");
+        pending = (async () => {
+          const initial = await this.setup(host);
+          const state = { transport: initial.transport, gateway: void 0 };
+          let reconnecting;
+          const gateway = new SshGateway(initial.transport, initial.runtime, () => reconnecting ??= (async () => {
+            const next = await this.setup(host);
+            const previous = state.transport;
+            state.transport = next.transport;
+            await previous.close();
+            return next;
+          })().finally(() => {
+            reconnecting = void 0;
+          }));
+          state.gateway = gateway;
+          try {
+            if (this.closed) throw new Error("The local app is shutting down");
+            this.sessions.set(id, state);
+            this.directoryCache = void 0;
+            return state;
+          } catch (error) {
+            await gateway.close();
+            await state.transport.close();
+            throw error;
+          }
+        })();
+        this.pending.set(id, pending);
+        void pending.finally(() => this.pending.delete(id)).catch(() => void 0);
+      }
+      session = await pending;
+    }
+    return { url: `/computer/${id}/` };
+  }
+  /** Install an independent host. The workspace stays private and keeps running. */
+  async setupTeamServer(id, body) {
+    this.assertBrowse();
+    await this.load();
+    if (this.teamRemoving.has(id)) throw new HttpError(409, "Wait for team server deletion to finish");
+    if (this.closed) throw new HttpError(503, "The local app is shutting down");
+    const host = this.hosts.find((item) => item.id === id);
+    if (!host) throw new HttpError(404, "SSH connection not found");
+    const workspace = this.sessions.get(id);
+    if (!workspace || workspace.gateway.error) throw new HttpError(409, "Connect to this server in SSH connections first");
+    const remotePort = body.remotePort ?? 4318;
+    if (!Number.isInteger(remotePort) || Number(remotePort) < 1 || Number(remotePort) > 65535) throw new HttpError(400, "Choose a team port from 1 to 65535");
+    let pending = this.teamPending.get(id);
+    if (!pending) {
+      pending = (async () => {
+        const initial = await this.setup(host, Number(remotePort));
+        const state = { transport: initial.transport, gateway: void 0 };
+        state.gateway = new SshGateway(initial.transport, initial.runtime, async () => {
+          const next = await this.setup(host, initial.runtime.remotePort ?? Number(remotePort));
+          const previous = state.transport;
+          state.transport = next.transport;
+          await previous.close();
+          return next;
+        }, "/api/team-host-runtime");
+        try {
+          this.assertBrowse();
+          if (this.closed || !this.sessions.has(id)) throw new HttpError(409, "SSH disconnected during setup. Reconnect and resume; the team server stays installed.");
+          const previous = this.teamSessions.get(id);
+          this.teamSessions.set(id, state);
+          if (previous) {
+            await previous.gateway.close();
+            await previous.transport.close();
+          }
+          return { remotePort: initial.runtime.remotePort ?? Number(remotePort), currentVersion: initial.currentVersion };
+        } catch (error) {
+          await state.gateway.close();
+          await state.transport.close();
+          throw error;
+        }
+      })();
+      this.teamPending.set(id, pending);
+      void pending.finally(() => this.teamPending.delete(id)).catch(() => void 0);
+    }
+    return pending;
+  }
+  async teamAutostart(id, action = "status") {
+    if (this.teamRemoving.has(id)) throw new HttpError(409, "Wait for team server deletion to finish");
+    this.assertBrowse();
+    if (!["status", "enable", "disable"].includes(action)) throw new HttpError(400, "Choose status, enable or disable for automatic startup");
+    if (this.teamPending.has(id)) throw new HttpError(409, "Wait for team server setup to finish");
+    const session = this.teamSessions.get(id);
+    if (!session || !this.sessions.has(id)) throw new HttpError(409, "Open team server setup on this SSH connection first");
+    const code = await readFile(new URL("./team-autostart.mjs", import.meta.url), "utf8");
+    const text = await session.transport.bootstrap(code + "\nawait main();", JSON.stringify({ action }));
+    const result = JSON.parse(text.split(/\r?\n/).find((line) => line.startsWith("CODEFLOW_AUTOSTART "))?.slice(19) ?? "null");
+    if (!result || typeof result.enabled !== "boolean" || typeof result.supported !== "boolean" || typeof result.message !== "string") throw new HttpError(502, "The server returned an invalid automatic startup status");
+    return result;
+  }
+  async teamServerStatus(id) {
+    this.assertBrowse();
+    await this.load();
+    if (!this.hosts.some((host) => host.id === id)) throw new HttpError(404, "SSH connection not found");
+    const session = this.sessions.get(id);
+    if (!session || session.gateway.error) throw new HttpError(409, "Connect to this server to check its team server");
+    const code = await readFile(new URL("./team-status.mjs", import.meta.url), "utf8");
+    const text = await session.transport.bootstrap(code, "");
+    const result = JSON.parse(text.split(/\r?\n/).find((line) => line.startsWith("CODEFLOW_TEAM_STATUS "))?.slice(21) ?? "null");
+    if (!result || !["running", "not-installed", "unavailable"].includes(result.state)) throw new HttpError(502, "Could not read the team server status");
+    return result;
+  }
+  async removeTeamServer(id) {
+    this.assertBrowse();
+    await this.load();
+    if (this.teamPending.has(id)) throw new HttpError(409, "Wait for team server setup to finish");
+    const session = this.sessions.get(id);
+    if (!session || session.gateway.error) throw new HttpError(409, "Connect to this server before deleting its team server");
+    if (this.teamRemoving.has(id)) throw new HttpError(409, "Team server deletion is already in progress");
+    this.teamRemoving.add(id);
+    try {
+      const code = await readFile(new URL("./team-remove.mjs", import.meta.url), "utf8");
+      const text = await session.transport.bootstrap(code + '\nconsole.log("CODEFLOW_TEAM_REMOVED " + JSON.stringify(await removeTeamServer()));', "");
+      const result = JSON.parse(text.split(/\r?\n/).find((line) => line.startsWith("CODEFLOW_TEAM_REMOVED "))?.slice(22) ?? "null");
+      if (!result?.removed) throw new HttpError(502, "Team server deletion could not be verified");
+      const previous = this.teamSessions.get(id);
+      this.teamSessions.delete(id);
+      if (previous) {
+        await previous.gateway.close();
+        await previous.transport.close();
+      }
+      return { removed: true };
+    } finally {
+      this.teamRemoving.delete(id);
+    }
+  }
+  async forwardTeamServer(id, req, res, path, origin) {
+    this.assertBrowse();
+    if (this.teamRemoving.has(id)) throw new HttpError(409, "Wait for team server deletion to finish");
+    const url = new URL(path, origin), method = req.method ?? "GET";
+    const allowed = method === "GET" && /^\/api\/(projects|accounts|remote|team\/board)$/.test(url.pathname) || method === "POST" && /^\/api\/(projects|accounts|remote(?:\/tls)?)$/.test(url.pathname) || method === "PUT" && /^\/api\/(accounts\/[^/]+|team\/profile|team\/projects\/[^/]+\/repositories)$/.test(url.pathname);
+    if (!allowed) throw new HttpError(404, "Unknown team server setup operation");
+    if (url.pathname.startsWith("/api/team/")) url.searchParams.set("teamConnection", "local");
+    const session = this.teamSessions.get(id);
+    if (!session || !this.sessions.has(id)) throw new HttpError(409, "Open team server setup on this SSH connection first");
+    const body = method === "GET" ? void 0 : await readJson(req, 192 * 1024);
+    return session.gateway.forward(req, res, url.pathname + url.search, origin, body);
+  }
+  async stopTeamServer(id) {
+    this.assertBrowse();
+    if (this.teamPending.has(id)) throw new HttpError(409, "Wait for team server setup to finish");
+    const session = this.teamSessions.get(id);
+    if (!session) throw new HttpError(409, "Open team server setup before stopping it");
+    await session.gateway.json("/api/team-host-runtime/stop", "POST", {});
+    this.teamSessions.delete(id);
+    await session.gateway.close();
+    await session.transport.close();
+  }
+  directoryPending;
+  directoryCache;
+  assertBrowse() {
+    if (this.options.canBrowse && !this.options.canBrowse()) throw new HttpError(409, "Filesystem restrictions pause connected projects");
+  }
+  async projectDirectory() {
+    this.assertBrowse();
+    await this.load();
+    let remotes = this.directoryCache && this.directoryCache.until > Date.now() ? this.directoryCache.value : void 0;
+    if (!remotes) {
+      this.directoryPending ??= Promise.all([...this.sessions].map(async ([id, session]) => {
+        const host = this.hosts.find((host2) => host2.id === id);
+        try {
+          const rows = await session.gateway.json("/api/projects", "GET", void 0, 5e3);
+          if (!Array.isArray(rows) || rows.some((p) => !p || typeof p.id !== "string" || typeof p.name !== "string")) throw new Error("Invalid project list");
+          return { id, name: host.name, projects: rows.map(({ id: id2, name }) => ({ id: id2, name })) };
+        } catch {
+          return { id, name: host.name, projects: [], error: "Connection unavailable" };
+        }
+      })).finally(() => {
+        this.directoryPending = void 0;
+      });
+      remotes = await this.directoryPending;
+      this.directoryCache = { until: Date.now() + 5e3, value: remotes };
+    }
+    this.assertBrowse();
+    return [{ id: "local", name: "This computer", projects: (this.options.localProjects?.() ?? []).map(({ id, name }) => ({ id, name })) }, ...remotes.filter((host) => this.sessions.has(host.id)).sort((a, b) => this.hosts.findIndex((host) => host.id === a.id) - this.hosts.findIndex((host) => host.id === b.id))];
+  }
+  async context(id) {
+    this.assertBrowse();
+    await this.load();
+    const host = this.hosts.find((host2) => host2.id === id);
+    if (!host) throw new HttpError(404, "Computer not found");
+    const session = this.sessions.get(id);
+    return { kind: "ssh", id, name: host.name, connected: !!session, error: session?.gateway.error };
+  }
+  async forward(id, req, res, path, origin) {
+    this.assertBrowse();
+    const session = this.sessions.get(id);
+    if (!session) throw new HttpError(409, "This computer is disconnected. Reconnect it in Settings.");
+    return session.gateway.forward(req, res, path, origin);
+  }
+  async disconnect(id) {
+    await this.teamPending.get(id)?.catch(() => void 0);
+    const team = this.teamSessions.get(id);
+    this.teamSessions.delete(id);
+    if (team) {
+      await team.gateway.close();
+      await team.transport.close();
+    }
+    const session = this.sessions.get(id) ?? await this.pending.get(id)?.catch(() => void 0);
+    this.sessions.delete(id);
+    this.directoryCache = void 0;
+    if (session) {
+      await session.gateway.close();
+      await session.transport.close();
+    }
+  }
+  async remove(id) {
+    await this.disconnect(id);
+    await this.change(() => {
+      this.hosts = this.hosts.filter((host) => host.id !== id);
+    });
+  }
+  async stop(id) {
+    const session = this.sessions.get(id);
+    if (!session) throw new HttpError(409, "Connect to this server before stopping its backend");
+    await session.gateway.json("/api/ssh-runtime/stop", "POST", {});
+    await this.disconnect(id);
+  }
+  async close() {
+    this.closed = true;
+    await Promise.allSettled([.../* @__PURE__ */ new Set([...this.sessions.keys(), ...this.pending.keys()])].map((id) => this.disconnect(id)));
+  }
+}
+export {
+  SshProjects
+};

package/src/ssh-projects/team-autostart.mjs

@@ -0,0 +1,93 @@
+// Fixed application code sent over SSH. User input selects only a named lifecycle action.
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const unit = 'codeflow-team-server.service';
+const marker = '# Managed by Code Flow team server setup';
+const execute = promisify(execFile);
+const quoteUnit = (value, command = false) => {
+  if (/[\x00-\x1f\x7f]/.test(value)) throw new Error('The service path contains unsupported control characters');
+  return '"' + value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%').replaceAll('$', () => command ? '$$' : '$') + '"';
+};
+export function serviceUnit(root, node, path) {
+  return `${marker}
+[Unit]
+Description=Code Flow team server
+StartLimitIntervalSec=0
+
+[Service]
+Type=simple
+ExecStart=${quoteUnit(node, true)} ${quoteUnit(join(root, 'service-bootstrap.mjs'), true)} --team-server --service
+WorkingDirectory=${quoteUnit(root)}
+Environment=${quoteUnit('PATH=' + path)}
+Restart=on-failure
+RestartSec=10s
+KillMode=mixed
+TimeoutStopSec=45s
+UMask=0077
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+export async function configureAutostart(action, options = {}) {
+  if (!['status', 'enable', 'disable'].includes(action)) throw new Error('Unknown automatic startup action');
+  const home = options.home ?? homedir(), platform = options.platform ?? process.platform;
+  const uid = String(options.uid ?? process.getuid?.());
+  const root = join(home, '.codeflow', 'team-server');
+  const path = options.path ?? process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
+  const node = options.node ?? process.execPath;
+  const run = options.run ?? (async (file, args) => {
+    const runtime = process.env.XDG_RUNTIME_DIR || `/run/user/${uid}`;
+    return (await execute(file, args, { timeout: 10000, maxBuffer: 16384, env: { ...process.env, XDG_RUNTIME_DIR: runtime, DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS || `unix:path=${runtime}/bus` } })).stdout.trim();
+  });
+  if (platform !== 'linux') return { supported: false, enabled: false, message: 'Automatic startup currently supports Linux servers with systemd. This server can still be started from setup.' };
+  const systemctl = (...args) => run('systemctl', ['--user', '--no-ask-password', ...args]);
+  try { await systemctl('show-environment'); }
+  catch { return { supported: false, enabled: false, message: 'The systemd user service manager is unavailable. Ask the server administrator to enable systemd user services for this SSH account, then reconnect and check again.' }; }
+  const unitPath = join(home, '.config', 'systemd', 'user', unit);
+  const existing = await readFile(unitPath, 'utf8').catch(error => { if (error.code !== 'ENOENT') throw error; return ''; });
+  if (existing && !existing.startsWith(marker + '\n')) throw new Error('A service named codeflow-team-server.service already exists and is not managed by Code Flow. Ask the administrator to resolve the name conflict.');
+  let prepared = false;
+  try { await readFile(join(root, 'service-bootstrap.mjs')); await readFile(join(root, 'service-package.json')); prepared = true; } catch { /* older installation */ }
+  let linger = await run('loginctl', ['show-user', uid, '--property=Linger', '--value']).then(value => value.trim() === 'yes', () => false);
+  if (action === 'enable') {
+    if (!prepared) throw new Error('Stop the team server and set it up again with this Code Flow version before enabling automatic startup. Saved projects and accounts will be kept.');
+    if (!linger) {
+      await run('loginctl', ['--no-ask-password', 'enable-linger', uid]).catch(() => undefined);
+      linger = await run('loginctl', ['show-user', uid, '--property=Linger', '--value']).then(value => value.trim() === 'yes', () => false);
+      if (!linger) return { supported: true, enabled: false, unitEnabled: !!existing && await systemctl("is-enabled", unit).then(value => value.trim() === "enabled", () => false), message: 'An administrator must allow this account’s services to start before login. Run the command on the remote server, then enable automatic startup again.', command: `sudo loginctl enable-linger ${uid}` };
+    }
+    await mkdir(join(home, '.config', 'systemd', 'user'), { recursive: true, mode: 0o700 });
+    const temporary = unitPath + '.tmp';
+    await writeFile(temporary, serviceUnit(root, node, path), { mode: 0o600 });
+    await rename(temporary, unitPath);
+    await systemctl('daemon-reload');
+    // Enable for the next boot. Do not interrupt or duplicate the already-running server.
+    await systemctl('enable', unit);
+  } else if (action === 'disable' && existing) {
+    await systemctl('disable', unit);
+    // Linger is shared by all of the account's services; leave it in place.
+  }
+  const installed = !!existing || action === 'enable';
+  const unitEnabled = installed && await systemctl('is-enabled', unit).then(value => value.trim() === 'enabled', () => false);
+  const enabled = !!unitEnabled && linger && prepared;
+  return { supported: true, enabled, unitEnabled: !!unitEnabled, linger, message: enabled
+    ? 'Automatic startup is enabled and verified. The team server will start after reboot, without an SSH login.'
+    : unitEnabled ? 'The service is enabled, but startup before login is not ready. Enable automatic startup again to repair its configuration.'
+    : 'Automatic startup is off. The current team server keeps running; enable this to start it after reboot.' };
+}
+
+export async function main() {
+  try {
+    let text = ''; process.stdin.setEncoding('utf8');
+    for await (const chunk of process.stdin) { text += chunk; if (text.length > 8192) throw new Error('Automatic startup request is too large'); }
+    const body = JSON.parse(text);
+    const result = await configureAutostart(body.action);
+    process.stdout.write('CODEFLOW_AUTOSTART ' + JSON.stringify(result) + '\n');
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+}

package/src/ssh-projects/team-remove.mjs

@@ -0,0 +1,69 @@
+// Fixed SSH lifecycle operation. The only removable directory is this account's
+// dedicated team-server installation; repository paths are never followed.
+import { readFile, lstat, rm, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+export async function removeTeamServer(options = {}) {
+  const home = options.home ?? homedir();
+  const root = join(home, ".codeflow", "team-server");
+  const exists = async path => lstat(path).catch(error => { if (error.code !== "ENOENT") throw error; return null; });
+  for (const path of [join(home, ".codeflow"), root]) {
+    const stat = await exists(path);
+    if (stat?.isSymbolicLink()) throw new Error("Team server storage is a symbolic link. Remove it manually after checking its target.");
+  }
+  const unitPath = join(home, ".config/systemd/user/codeflow-team-server.service");
+  const unit = await exists(unitPath);
+  if (!await exists(root)) {
+    if (unit) throw new Error("The startup service exists without team storage. Check it manually before deleting the installation.");
+    return { removed: true };
+  }
+  if (unit && (unit.isSymbolicLink() || !(await readFile(unitPath, "utf8")).startsWith("# Managed by Code Flow team server setup\n"))) throw new Error("The startup service is not managed by Code Flow. No team data was deleted.");
+  // Share bootstrap's atomic lock so setup cannot launch a backend during deletion.
+  const bootId = process.platform === "linux" ? await readFile("/proc/sys/kernel/random/boot_id", "utf8").then(value => value.trim()).catch(() => undefined) : undefined;
+  const lock = join(root, bootId ? `bootstrap.${bootId}.lock` : "bootstrap.lock");
+  try { await mkdir(lock, { mode: 0o700 }); }
+  catch (error) {
+    if (error.code === "EEXIST") throw new Error("Team server setup or deletion is already running. Wait, then retry.");
+    throw error;
+  }
+  try {
+    const runtime = JSON.parse(await readFile(join(root, "runtime.json"), "utf8"));
+    if (runtime?.protocol !== 1 || !Number.isInteger(runtime.port) || runtime.port < 1 || runtime.port > 65535
+      || !Number.isInteger(runtime.pid) || runtime.pid <= 0 || !/^[a-f0-9]{64}$/.test(runtime.token ?? "")
+      || !/^[a-f0-9]{32}$/.test(runtime.instance ?? "")) throw new Error("Cannot verify the team server process. No team data was deleted.");
+    const request = options.request ?? fetch;
+    const get = (path, method = "GET") => request(`http://127.0.0.1:${runtime.port}${path}`, {
+      method, headers: { authorization: `Bearer ${runtime.token}` }, signal: AbortSignal.timeout(5000), redirect: "error",
+    });
+    let identity;
+    try { const response = await get("/api/team-host-runtime"); if (response.ok) identity = await response.json(); } catch { /* A stopped installation can be removed once its PID is gone. */ }
+    if (identity) {
+      if (identity.instance !== runtime.instance) throw new Error("The server identity changed. No team data was deleted.");
+      const stopped = await get("/api/team-host-runtime/stop", "POST");
+      if (!stopped.ok) throw new Error("Finish running team work and close terminals before deleting the team server.");
+    }
+    const alive = options.alive ?? (pid => { try { process.kill(pid, 0); return true; } catch (error) { return error.code !== "ESRCH"; } });
+    // Do not force-kill a process, including a recycled PID.
+    for (let attempt = 0; alive(runtime.pid); attempt++) {
+      if (attempt >= 50) throw new Error("The team server is still shutting down. Wait, then retry deletion. No team data was deleted.");
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    if (unit) {
+      const execute = promisify(execFile);
+      const run = options.run ?? (async args => {
+        const uid = process.getuid?.();
+        const runtimeDir = process.env.XDG_RUNTIME_DIR || `/run/user/${uid}`;
+        await execute("systemctl", ["--user", "--no-ask-password", ...args], { timeout: 10000, env: { ...process.env, XDG_RUNTIME_DIR: runtimeDir, DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS || `unix:path=${runtimeDir}/bus` } });
+      });
+      await run(["disable", "--now", "codeflow-team-server.service"]);
+      await rm(unitPath);
+      await run(["daemon-reload"]);
+    }
+    await rm(root, { recursive: true });
+  } finally { await rm(lock, { recursive: true, force: true }); }
+
+  return { removed: true };
+}