acp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157// Ported from the Rust plugin's terminal.rs tests: the command is a
// scripted fake child behind `api.process.spawn`.
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Scope from "effect/Scope";
import * as ManagedRuntime from "effect/ManagedRuntime";
import { liveLayer } from "convergence/effect";
import type { Api } from "convergence";
import { afterEach } from "node:test";
import { test } from "node:test";
import assert from "node:assert/strict";
import { fakeApi, settle } from "../sdk/testing.ts";
import { OutputBuffer, Terminals } from "./terminal.ts";

const cleanups: (() => Promise<void>)[] = [];
afterEach(async () => {
  for (const close of cleanups.splice(0)) await close();
});
function terminalsFor(api: Api) {
  const scope = Scope.makeUnsafe();
  const runtime: ManagedRuntime.ManagedRuntime<import("convergence/effect").PluginServices, never> =
    ManagedRuntime.make(
      liveLayer(
        api,
        (effect) => runtime.runPromise(effect),
        () => {},
      ),
    );
  const terminals = new Terminals(scope);
  cleanups.push(async () => {
    await runtime.runPromise(terminals.releaseAll());
    await runtime.runPromise(Scope.close(scope, Exit.void));
    await runtime.dispose();
  });
  return {
    create: (input: Parameters<Terminals["create"]>[0]) => runtime.runPromise(terminals.create(input)),
    wait: (id: string) => runtime.runPromise(terminals.wait(id)),
    kill: (id: string) => runtime.runPromise(terminals.kill(id)),
    release: (id: string) => runtime.runPromise(terminals.release(id)),
    releaseSession: (id: string) => runtime.runPromise(terminals.releaseSession(id)),
    output: (id: string) => terminals.output(id),
    views: (id: string) => terminals.views(id),
  };
}
function request(command: string, args: string[], extra = {}) {
  return { sessionId: "s1", command, args, ...extra };
}

test("a terminal captures output and its exit code", async () => {
  const api = fakeApi({ onSpawn: () => () => {} });
  const terminals = terminalsFor(api);
  const id = await terminals.create(
    request("sh", ["-c", "echo hello; echo oops 1>&2; exit 3"], { env: [{ name: "A", value: "1" }], cwd: "/w" }),
  );
  const peer = api.peers[0];
  assert.equal(peer.program, "sh");
  assert.deepEqual(peer.options, { cwd: "/w", env: { A: "1" } });
  assert.ok(peer.stdinClosed, "a terminal command gets no input");
  peer.stdout.push("hello\n");
  peer.stderr.push("oops\n");
  await settle();
  const running = terminals.output(id);
  assert.equal(running.exit, null);
  peer.exit(3);
  const exit = await terminals.wait(id);
  assert.equal(exit.code, 3);
  const { output, truncated, exit: status } = terminals.output(id);
  assert.match(output, /hello/);
  assert.match(output, /oops/);
  assert.equal(truncated, false);
  assert.ok(status);
  assert.equal(status.code, 3);

  const views = terminals.views("s1");
  const view = views.get(id);
  assert.ok(view);
  assert.equal(view.command, "sh -c echo hello; echo oops 1>&2; exit 3");
  assert.equal(view.exitCode, 3);
  assert.equal(terminals.views("other").size, 0);

  await terminals.release(id);
  assert.throws(() => terminals.output(id), /unknown terminal/);
});

test("killing and releasing a running command stops it, and a wait learns it", async () => {
  const api = fakeApi({ onSpawn: () => () => {} });
  const terminals = terminalsFor(api);
  const id = await terminals.create(request("sleep", ["100"]));
  const waiting = terminals.wait(id);
  await terminals.kill(id);
  assert.deepEqual(api.peers[0].kills, ["SIGKILL"]);
  const exit = await waiting;
  assert.equal(exit.signal, "SIGKILL");

  const other = await terminals.create(request("sleep", ["100"]));
  api.peers[1].exit = () => {}; // a command that ignores the kill
  const pending = terminals.wait(other);
  await terminals.release(other);
  await assert.rejects(pending, /released before it exited/);
});

test("a session's terminals are released with it", async () => {
  const api = fakeApi({ onSpawn: () => () => {} });
  const terminals = terminalsFor(api);
  const mine = await terminals.create(request("a", []));
  const theirs = await terminals.create({ ...request("b", []), sessionId: "s2" });
  await terminals.releaseSession("s1");
  assert.throws(() => terminals.output(mine));
  assert.doesNotThrow(() => terminals.output(theirs));
});

test("a spawn the host refuses names the command", async () => {
  const api = fakeApi({ onSpawn: () => new Error("PermissionNotGranted") });
  await assert.rejects(terminalsFor(api).create(request("rm", ["-rf"])), /could not run rm/);
});

test("the buffer keeps the most recent bytes", () => {
  const buffer = new OutputBuffer(4);
  buffer.push("0123456789");
  assert.equal(buffer.text, "6789");
  assert.equal(buffer.truncated, true);
  // A character is never split: `é` is two bytes.
  const accents = new OutputBuffer(3);
  accents.push("aéé");
  assert.equal(accents.text, "é");
});

test("terminal inputs retain coercion and skip malformed environment entries individually", async () => {
  const api = fakeApi({ onSpawn: () => () => {} });
  const terminals = terminalsFor(api);
  const id = await terminals.create({
    sessionId: "s1",
    command: "sh",
    args: [1, true],
    env: [null, { name: "A", value: 2 }, "bad", { name: "B" }],
    outputByteLimit: null,
  });
  assert.deepEqual(api.peers[0].args, ["1", "true"]);
  assert.deepEqual(api.peers[0].options.env, { A: "2", B: "" });
  api.peers[0].stdout.push("hello");
  await settle();
  assert.equal(terminals.output(id).output, "hello");
});

test("creating a terminal does not wait for its input to close", { timeout: 1000 }, async () => {
  const api = fakeApi({ onSpawn: () => () => {} });
  const spawn = api.process.spawn;
  api.process.spawn = async (...args) => {
    const child = await spawn(...args);
    child.stdin.close = () => new Promise<never>(() => {});
    return child;
  };
  const terminals = terminalsFor(api);
  const id = await terminals.create(request("sh", []));
  assert.equal(terminals.output(id).output, "");
  await terminals.release(id);
});