@cueloop/client 0.1.0-alpha.32 → 0.1.0-alpha.34

package/src/session-controller.ts

@@ -24,13 +24,36 @@ import {
   type VerdictKind,
 } from "@cueloop/schema";
 import { loadBundledExporters, type BundledExporter } from "./integrations";
-import { collaboratorAnnotations, publishShare, pullShare, pushShare, shareIdFromLine } from "./share";
+import {
+  collaboratorAnnotations,
+  publishShare,
+  pullShare,
+  pushShare,
+  shareIdFromLine,
+} from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
+import {
+  changeRejectionForRow,
+  curateDiff,
+  hunkRejectionForRow,
+  isRowRejected,
+  parseFileDiff,
+  rejectsWholeHunk,
+  sameRejection,
+  type HunkRejection,
+} from "./diff-hunk-curate";
+import type { FileDiffMetadata } from "@pierre/diffs";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
 import { focusHerdrPane } from "./herdr";
-import { persistAutoClose, persistReviewState, persistReviewWidth, type AutoClose, type CueloopConfig } from "./config";
+import {
+  persistAutoClose,
+  persistReviewState,
+  persistReviewWidth,
+  type AutoClose,
+  type CueloopConfig,
+} from "./config";
 import type { ReviewPanelMode } from "./review-panel";
 
 /**
@@ -50,10 +73,49 @@ export const DEFAULT_AUTO_CLOSE = 5;
 /** How often an open shared plan re-pulls collaborator notes (ADR 0005 stage 2). */
 export const SHARE_POLL_MS = 4000;
 
+/** Shared empty set so "nothing rejected" is a stable identity for renders. */
+const EMPTY_REJECTED_ROWS: Set<number> = new Set();
+
+/** Shared empty list so "nothing curated out" is a stable identity for renders. */
+const EMPTY_CURATION_ITEMS: CurationItem[] = [];
+
+/** Status shown when a curated-out removal (diff rejection or plan cut) is restored. */
+const REMOVAL_RESTORED_STATUS = "removal restored";
+
+export interface ToastState {
+  title?: string;
+  body: string;
+}
+
+/**
+ * One removed piece projected for the review rail, unified across both review
+ * kinds: a diff hunk/change the owner curated out, or a plan block they cut.
+ * `source` tells restore and reveal which path to take; `preview` is the removed
+ * content (a few lines) the card renders struck through; `revealIndex` is the
+ * diff row (diff) or display block (plan) to scroll to and restore against.
+ */
+export interface CurationItem {
+  id: string;
+  source: "diff" | "plan";
+  preview: string[];
+  revealIndex: number;
+}
+
+/** Stable id for a rejection's rail item: diff:path#hunk#change (or #hunk for a whole hunk). */
+export function curationItemId(rejection: HunkRejection): string {
+  return `diff:${rejection.path}#${rejection.hunkIndex}#${rejection.changeIndex ?? "hunk"}`;
+}
+
+/** Stable id for a plan cut's rail item, keyed on its fixed base-content line range. */
+function planCutId(base: { lineStart: number; lineEnd: number }): string {
+  return `plan:${base.lineStart}-${base.lineEnd}`;
+}
+
 export interface ControllerSnapshot {
   session: ReviewSession | null;
   inbox: ReviewSession[] | null;
   status: string;
+  toast: ToastState | null;
   error: string | null;
   completion: Completion;
   /**
@@ -96,6 +158,8 @@ export interface ReviewController {
   /** Loaded config parts the controller acts on: auto-close and exporters. */
   applyConfig(config: CueloopConfig): void;
   setStatus(message: string): void;
+  showToast(body: string, title?: string): void;
+  dismissToast(): void;
   /** Derived projections, cached per session identity. */
   display(): DisplayBlock[];
   rows(): DiffRow[];
@@ -110,13 +174,29 @@ export interface ReviewController {
   setSelfName(name: string): void;
   /** Cut the block under the cursor, or restore a cut one. */
   cut(displayIndex: number): void;
+  /** Toggle rejection of the whole hunk under the diff cursor (owner curation). */
+  toggleRejectHunk(rowIndex: number): void;
+  /** Toggle rejection of the single change under the diff cursor (owner curation). */
+  toggleRejectChange(rowIndex: number): void;
+  /** Rendered row indices dropped by the current reject decisions (for dimming). */
+  rejectedRows(): Set<number>;
+  /** The curated-out rejections as rail items, in the order they were rejected. */
+  curationItems(): CurationItem[];
+  /** Undo one curation item by id: drop the rejection and recompute the working copy. */
+  restoreCuration(id: string): void;
   /** The $EDITOR hand-off on the working copy. */
   edit(): void;
   /**
    * Anchor and store an annotation; both plan and diff anchor constructions.
    * Returns the minted annotation id so the view can select the new card.
    */
-  annotate(kind: "comment" | "suggestion", displayIndex: number, start: number, end: number, body: string): string | undefined;
+  annotate(
+    kind: "comment",
+    displayIndex: number,
+    start: number,
+    end: number,
+    body: string,
+  ): string | undefined;
   /** Rewrite a stored annotation's body in place (the rail-card edit). */
   updateAnnotation(id: string, body: string): void;
   removeAnnotation(id: string): void;
@@ -161,6 +241,7 @@ class Controller implements ReviewController {
     session: null,
     inbox: null,
     status: "",
+    toast: null,
     error: null,
     completion: { phase: "idle" },
     editOrphanCount: 0,
@@ -176,11 +257,20 @@ class Controller implements ReviewController {
   private shareRun: object | null = null;
   /** Projections keyed by session identity so renders reuse one computation. */
   private derivedFor: ReviewSession | null = null;
-  private derived: { display: DisplayBlock[]; rows: DiffRow[]; files: WalkFile[] } = {
+  private derived: {
+    display: DisplayBlock[];
+    rows: DiffRow[];
+    files: WalkFile[];
+    /** Per-path parsed diff models, for hunk curation; empty when files absent. */
+    models: Map<string, FileDiffMetadata>;
+  } = {
     display: [],
     rows: [],
     files: [],
+    models: new Map(),
   };
+  /** The owner's per-hunk/change reject decisions for the open diff session. */
+  private rejections: HunkRejection[] = [];
 
   constructor(private readonly options: ReviewControllerOptions) {
     this.readOnly = options.readOnly ?? false;
@@ -202,7 +292,9 @@ class Controller implements ReviewController {
   connect(): void {
     void (async () => {
       try {
-        const openClient = this.options.openClient ?? (() => DaemonClient.connect({ home: this.options.home, autostart: true }));
+        const openClient =
+          this.options.openClient ??
+          (() => DaemonClient.connect({ home: this.options.home, autostart: true }));
         const client = await openClient();
         if (this.closed) return void client.close();
         this.client = client;
@@ -248,16 +340,28 @@ class Controller implements ReviewController {
     this.update({ status: message });
   }
 
+  showToast(body: string, title?: string): void {
+    this.update({ toast: { body, title } });
+  }
+
+  dismissToast(): void {
+    if (this.snapshot.toast) this.update({ toast: null });
+  }
+
   // ── derived projections ─────────────────────
   private ensureDerived(): void {
     const session = this.snapshot.session;
     if (this.derivedFor === session) return;
     this.derivedFor = session;
-    const rows = session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
+    const rows =
+      session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
+    const models = new Map<string, FileDiffMetadata>();
+    for (const file of session?.artifact.files ?? []) models.set(file.path, parseFileDiff(file));
     this.derived = {
       display: session ? buildDisplay(session.artifact.content, session.workingCopy) : [],
       rows,
       files: walkFiles(rows),
+      models,
     };
   }
 
@@ -302,14 +406,17 @@ class Controller implements ReviewController {
 
   /** Optimistic apply: the daemon response is the next session snapshot. */
   private apply(mutation: Promise<ReviewSession>): void {
-    mutation.then((session) => this.update({ session })).catch((error: unknown) =>
-      this.setStatus(String(error instanceof Error ? error.message : error)),
-    );
+    mutation
+      .then((session) => this.update({ session }))
+      .catch((error: unknown) =>
+        this.setStatus(String(error instanceof Error ? error.message : error)),
+      );
   }
 
   // ── verbs ───────────────────────────────────
   open(id: string): void {
     this.locallyViewed.clear();
+    this.rejections = [];
     const cached = this.snapshot.inbox?.find((candidate) => candidate.id === id);
     if (cached) this.update({ session: cached });
     else void this.refreshSession(id);
@@ -319,7 +426,9 @@ class Controller implements ReviewController {
     this.client
       ?.sessionDelete(id)
       .then(() => this.setStatus("plan deleted"))
-      .catch((error: unknown) => this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`));
+      .catch((error: unknown) =>
+        this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`),
+      );
   }
 
   setSelfName(name: string): void {
@@ -335,18 +444,185 @@ class Controller implements ReviewController {
     if (!block) return;
     const working = this.working();
     if (block.type === "del") {
-      const line = restoreLine(nextWorkBlock(this.display(), displayIndex), working.split("\n").length);
-      // restoreBlock returns undefined when the block structure round-trips
-      // to the submitted revision - the working copy is gone
-      const restored = restoreBlock(session.artifact.content, working, block.base!, line);
-      this.setWorkingCopy(restored);
-      this.setStatus("cut restored");
+      this.restoreDelBlock(block, displayIndex);
     } else if (block.work) {
       this.setWorkingCopy(cutBlock(working, block.work));
       this.setStatus("block cut - it serializes into the diff");
     }
   }
 
+  /** Re-insert a cut plan block at the next surviving block's line (Cut toggle + rail undo). */
+  private restoreDelBlock(block: DisplayBlock, displayIndex: number): void {
+    const session = this.snapshot.session;
+    if (!session || !block.base) return;
+    const working = this.working();
+    const line = restoreLine(
+      nextWorkBlock(this.display(), displayIndex),
+      working.split("\n").length,
+    );
+    // restoreBlock returns undefined when the block structure round-trips to the
+    // submitted revision - the working copy is back to pristine and is dropped
+    const restored = restoreBlock(session.artifact.content, working, block.base, line);
+    this.setWorkingCopy(restored);
+    this.setStatus(REMOVAL_RESTORED_STATUS);
+  }
+
+  // ── diff hunk curation ──────────────────────
+  /** The parsed model and row for a curation action, or null with a status set. */
+  private curationRow(rowIndex: number): { row: DiffRow; model: FileDiffMetadata } | null {
+    const session = this.snapshot.session;
+    if (!session || session.status === "resolved") return null;
+    if (!session.artifact.files) {
+      this.setStatus("hunk curation needs full file contents (PR diffs cannot be curated)");
+      return null;
+    }
+    const row = this.rows()[rowIndex];
+    if (!row || row.kind === "file" || row.kind === "hunk") {
+      this.setStatus("move to a code line to curate");
+      return null;
+    }
+    const model = this.derived.models.get(row.file);
+    if (!model) return null;
+    return { row, model };
+  }
+
+  toggleRejectHunk(rowIndex: number): void {
+    const located = this.curationRow(rowIndex);
+    if (!located) return;
+    const target = hunkRejectionForRow(located.row.file, located.model, located.row);
+    if (!target) return this.setStatus("no hunk under the cursor");
+    const wholeHunk = (rejection: HunkRejection): boolean => rejectsWholeHunk(rejection, target);
+    if (this.rejections.some(wholeHunk)) {
+      this.rejections = this.rejections.filter((rejection) => !wholeHunk(rejection));
+      this.setStatus("hunk restored");
+    } else {
+      // a whole-hunk reject supersedes any change-level rejects inside it
+      this.rejections = this.rejections.filter(
+        (rejection) =>
+          !(rejection.path === target.path && rejection.hunkIndex === target.hunkIndex),
+      );
+      this.rejections.push(target);
+      this.setStatus("hunk rejected - dropped from the working copy");
+    }
+    this.recomputeCuration();
+  }
+
+  toggleRejectChange(rowIndex: number): void {
+    const located = this.curationRow(rowIndex);
+    if (!located) return;
+    if (located.row.kind !== "add" && located.row.kind !== "del")
+      return this.setStatus("move to a changed line to reject a change");
+    const target = changeRejectionForRow(located.row.file, located.model, located.row);
+    if (!target) return this.setStatus("no change under the cursor");
+    const wholeCovers = this.rejections.some((rejection) => rejectsWholeHunk(rejection, target));
+    if (wholeCovers) return this.setStatus("the whole hunk is rejected - restore it first");
+    if (this.rejections.some((rejection) => sameRejection(rejection, target))) {
+      this.rejections = this.rejections.filter((rejection) => !sameRejection(rejection, target));
+      this.setStatus("change restored");
+    } else {
+      this.rejections.push(target);
+      this.setStatus("change rejected - dropped from the working copy");
+    }
+    this.recomputeCuration();
+  }
+
+  /** Recompute the curated patch and push it as the working copy (or clear it). */
+  private recomputeCuration(): void {
+    const files = this.snapshot.session?.artifact.files;
+    if (!files) return;
+    // no decisions left = the working copy reverts to the full submitted diff
+    this.setWorkingCopy(this.rejections.length ? curateDiff(files, this.rejections) : undefined);
+    // dimming reads `rejections` directly; a bare update forces the re-read
+    this.update({});
+  }
+
+  rejectedRows(): Set<number> {
+    this.ensureDerived();
+    if (!this.rejections.length) return EMPTY_REJECTED_ROWS;
+    const rejected = new Set<number>();
+    this.derived.rows.forEach((row, index) => {
+      const model = this.derived.models.get(row.file);
+      if (model && isRowRejected(row.file, model, row, this.rejections)) rejected.add(index);
+    });
+    return rejected;
+  }
+
+  curationItems(): CurationItem[] {
+    this.ensureDerived();
+    const session = this.snapshot.session;
+    if (!session) return EMPTY_CURATION_ITEMS;
+    return session.artifact.type === "diff" ? this.diffCurationItems() : this.planCurationItems();
+  }
+
+  restoreCuration(id: string): void {
+    // diff rejections drop from the reject list; a plan cut re-inserts its block
+    if (id.startsWith("diff:")) {
+      const kept = this.rejections.filter((rejection) => curationItemId(rejection) !== id);
+      if (kept.length === this.rejections.length) return;
+      this.rejections = kept;
+      this.setStatus(REMOVAL_RESTORED_STATUS);
+      this.recomputeCuration();
+      return;
+    }
+    const display = this.display();
+    const displayIndex = display.findIndex(
+      (block) => block.type === "del" && block.base && planCutId(block.base) === id,
+    );
+    if (displayIndex !== -1) this.restoreDelBlock(display[displayIndex]!, displayIndex);
+  }
+
+  /** The curated-out diff rejections as removal cards (newest decisions last). */
+  private diffCurationItems(): CurationItem[] {
+    if (!this.rejections.length) return EMPTY_CURATION_ITEMS;
+    const items: CurationItem[] = [];
+    for (const rejection of this.rejections) {
+      const rows = this.rowsForRejection(rejection);
+      const firstRow = rows[0];
+      items.push({
+        id: curationItemId(rejection),
+        source: "diff",
+        preview: rows.map(
+          (row) => `${row.kind === "add" ? "+" : "-"} ${row.text.replace(/\n$/, "")}`,
+        ),
+        revealIndex: firstRow ? this.derived.rows.indexOf(firstRow) : 0,
+      });
+    }
+    return items;
+  }
+
+  /** The cut plan blocks as removal cards, in document order. */
+  private planCurationItems(): CurationItem[] {
+    const items: CurationItem[] = [];
+    this.derived.display.forEach((block, displayIndex) => {
+      if (block.type !== "del" || !block.base) return;
+      items.push({
+        id: planCutId(block.base),
+        source: "plan",
+        preview: block.base.text.split("\n"),
+        revealIndex: displayIndex,
+      });
+    });
+    return items.length ? items : EMPTY_CURATION_ITEMS;
+  }
+
+  /** The change/deletion rows a rejection covers, for its preview and reveal row. */
+  private rowsForRejection(rejection: HunkRejection): DiffRow[] {
+    const model = this.derived.models.get(rejection.path);
+    if (!model) return [];
+    const rows: DiffRow[] = [];
+    for (const row of this.derived.rows) {
+      if (row.file !== rejection.path || (row.kind !== "add" && row.kind !== "del")) continue;
+      if (rejection.changeIndex === undefined) {
+        const target = hunkRejectionForRow(rejection.path, model, row);
+        if (target && target.hunkIndex === rejection.hunkIndex) rows.push(row);
+      } else {
+        const target = changeRejectionForRow(rejection.path, model, row);
+        if (target && sameRejection(target, rejection)) rows.push(row);
+      }
+    }
+    return rows;
+  }
+
   edit(): void {
     const session = this.snapshot.session;
     if (!session || session.status === "resolved") return;
@@ -377,7 +653,7 @@ class Controller implements ReviewController {
   }
 
   annotate(
-    kind: "comment" | "suggestion",
+    kind: "comment",
     displayIndex: number,
     start: number,
     end: number,
@@ -391,14 +667,15 @@ class Controller implements ReviewController {
     } else {
       const display = this.display();
       const workBlocks = display.filter((entry) => entry.work).map((entry) => entry.work!);
-      const workBlockIndex = display.slice(0, displayIndex + 1).filter((entry) => entry.work).length - 1;
+      const workBlockIndex =
+        display.slice(0, displayIndex + 1).filter((entry) => entry.work).length - 1;
       anchor = makeAnchor(workBlocks, workBlockIndex, start, end);
     }
     const wire = { id: newAnnotationId(), kind, anchor, body };
     const persisted = this.client!.sessionAnnotate(session.id, wire);
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus(kind === "suggestion" ? "suggestion added - the agent applies it" : "comment added");
+    this.setStatus("comment added");
     return wire.id;
   }
 
@@ -416,7 +693,10 @@ class Controller implements ReviewController {
   }
 
   // push only after the local write lands, so a rejected write never leaks to the share
-  private mirrorAnnotation(persisted: Promise<ReviewSession>, annotation: Omit<Annotation, "createdAt">): void {
+  private mirrorAnnotation(
+    persisted: Promise<ReviewSession>,
+    annotation: Omit<Annotation, "createdAt">,
+  ): void {
     const shareId = this.snapshot.session?.shareId;
     if (!shareId) return;
     void persisted.then(() => pushShare(shareId, [annotation])).catch(() => {});
@@ -492,7 +772,11 @@ class Controller implements ReviewController {
         for (const exporter of this.exporters) {
           if (!exporter.runsOn(verdict)) continue;
           void exporter.run(resolved).then((exportResult) => {
-            this.setStatus(exportResult.success && exportResult.path ? `exported to ${exportResult.path}` : `export failed: ${exportResult.error ?? "unknown"}`);
+            this.setStatus(
+              exportResult.success && exportResult.path
+                ? `exported to ${exportResult.path}`
+                : `export failed: ${exportResult.error ?? "unknown"}`,
+            );
           });
         }
         // Hand the reviewer back to the agent. The default is a visible
@@ -503,7 +787,9 @@ class Controller implements ReviewController {
         else if (typeof delay === "number") this.startCounting(delay);
         else this.startCounting(DEFAULT_AUTO_CLOSE);
       })
-      .catch((error: unknown) => this.setStatus(String(error instanceof Error ? error.message : error)));
+      .catch((error: unknown) =>
+        this.setStatus(String(error instanceof Error ? error.message : error)),
+      );
   }
 
   share(): void {
@@ -515,9 +801,12 @@ class Controller implements ReviewController {
         // Stamp the id back so a later pull knows which share to collect from.
         const shareId = shareIdFromLine(line);
         if (shareId && this.client) await this.client.sessionSetShareId(session.id, shareId);
-        this.setStatus(copied ? `✓ share link copied - ${line}` : line);
+        this.setStatus("");
+        this.showToast(line, copied ? "share link copied" : "share link");
       })
-      .catch((error: unknown) => this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`));
+      .catch((error: unknown) =>
+        this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`),
+      );
   }
 
   /**
@@ -532,7 +821,10 @@ class Controller implements ReviewController {
     const client = this.client;
     return pullShare(session.shareId)
       .then((remote) =>
-        client.sessionMergeShared(session.id, { annotations: collaboratorAnnotations(remote), participants: remote.participants }),
+        client.sessionMergeShared(session.id, {
+          annotations: collaboratorAnnotations(remote),
+          participants: remote.participants,
+        }),
       )
       .then(() => {})
       .catch(() => {});
@@ -550,7 +842,8 @@ class Controller implements ReviewController {
     this.shareRun = run;
     const tick = (): void => {
       void this.pullShared().finally(() => {
-        if (this.shareRun === run && !this.closed) this.sharePoll = this.clock.setTimeout(tick, SHARE_POLL_MS);
+        if (this.shareRun === run && !this.closed)
+          this.sharePoll = this.clock.setTimeout(tick, SHARE_POLL_MS);
       });
     };
     tick();

package/src/share.ts

@@ -6,7 +6,12 @@
  * Share button, so the two share exactly the same path.
  */
 
-import { DEFAULT_SHARE_HOST, DEFAULT_SHARE_PORT, SHARE_UPLOAD_USER, packSessionBlob } from "@cueloop/daemon/share-blob";
+import {
+  DEFAULT_SHARE_HOST,
+  DEFAULT_SHARE_PORT,
+  SHARE_UPLOAD_USER,
+  packSessionBlob,
+} from "@cueloop/daemon/share-blob";
 import type { Annotation, ReviewSession } from "@cueloop/schema";
 import { copyToClipboard } from "./clipboard";
 
@@ -28,9 +33,17 @@ export function shareIdFromLine(line: string): string | undefined {
 }
 
 /** Upload the session to the gateway and copy the resulting ssh line. */
-export async function publishShare(session: ReviewSession, target: ShareTarget = {}): Promise<ShareResult> {
-  const { stdout, stderr, code } = await runShareSsh("cueloop-share", packSessionBlob(session), target);
-  if (code !== 0) throw new Error(`gateway upload failed: ${stderr.trim() || `ssh exited ${code}`}`);
+export async function publishShare(
+  session: ReviewSession,
+  target: ShareTarget = {},
+): Promise<ShareResult> {
+  const { stdout, stderr, code } = await runShareSsh(
+    "cueloop-share",
+    packSessionBlob(session),
+    target,
+  );
+  if (code !== 0)
+    throw new Error(`gateway upload failed: ${stderr.trim() || `ssh exited ${code}`}`);
   const line = stdout.trim();
   if (!line.startsWith("ssh ")) throw new Error(`unexpected gateway reply: ${line || "(empty)"}`);
   const copied = await copyToClipboard(line);
@@ -58,17 +71,37 @@ export function collaboratorAnnotations(session: ReviewSession): Annotation[] {
  * them on their next refresh. Owner-gated at the gateway; the notes stay
  * unauthored (the planner's), unioned by id.
  */
-export async function pushShare(shareId: string, annotations: Array<Omit<Annotation, "createdAt">>, target: ShareTarget = {}): Promise<void> {
-  const { stderr, code } = await runShareSsh("cueloop-push", Buffer.from(JSON.stringify({ shareId, annotations })), target);
+export async function pushShare(
+  shareId: string,
+  annotations: Array<Omit<Annotation, "createdAt">>,
+  target: ShareTarget = {},
+): Promise<void> {
+  const { stderr, code } = await runShareSsh(
+    "cueloop-push",
+    Buffer.from(JSON.stringify({ shareId, annotations })),
+    target,
+  );
   if (code !== 0) throw new Error(`gateway push failed: ${stderr.trim() || `ssh exited ${code}`}`);
 }
 
 /** Run one `share@host:port` ssh command with `stdin`; hand back its streams and exit code. */
-async function runShareSsh(command: string, stdin: Buffer, target: ShareTarget): Promise<{ stdout: string; stderr: string; code: number }> {
+async function runShareSsh(
+  command: string,
+  stdin: Buffer,
+  target: ShareTarget,
+): Promise<{ stdout: string; stderr: string; code: number }> {
   const host = target.host ?? DEFAULT_SHARE_HOST;
   const port = target.port ?? DEFAULT_SHARE_PORT;
   const proc = Bun.spawn(
-    ["ssh", "-p", String(port), "-o", "StrictHostKeyChecking=accept-new", `${SHARE_UPLOAD_USER}@${host}`, command],
+    [
+      "ssh",
+      "-p",
+      String(port),
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+      `${SHARE_UPLOAD_USER}@${host}`,
+      command,
+    ],
     { stdin, stdout: "pipe", stderr: "pipe" },
   );
   const [stdout, stderr, code] = await Promise.all([