t3code-cli 0.10.0 → 0.12.0

package/src/cli/interaction/self-action.ts

@@ -0,0 +1,36 @@
+import * as Effect from "effect/Effect";
+
+import { SelfActionError } from "../error.ts";
+import { isAgentEnvironment } from "../format/output.ts";
+import type { T3CliEnvShape } from "../../config/env/env.ts";
+import type { CliRuntime } from "../runtime/service.ts";
+
+export const requireSelfActionConfirmation = Effect.fn("requireSelfActionConfirmation")(
+  function* (input: {
+    readonly threadId: string;
+    readonly force: boolean;
+    readonly cliRuntime: CliRuntime["Service"];
+    readonly t3CliEnv: T3CliEnvShape;
+    readonly action: string;
+  }) {
+    if (input.force) {
+      return;
+    }
+    if (!isAgentEnvironment(input.t3CliEnv)) {
+      return;
+    }
+    const callerThreadId = input.t3CliEnv.scope.t3codeThreadId;
+    if (callerThreadId === undefined || callerThreadId.length === 0) {
+      return;
+    }
+    if (input.threadId !== callerThreadId) {
+      return;
+    }
+    yield* Effect.fail(
+      new SelfActionError({
+        threadId: input.threadId,
+        message: `cannot ${input.action} thread ${input.threadId}: command targets the calling thread. Pass --force to confirm.`,
+      }),
+    );
+  },
+);

package/src/cli/message-input.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import { ProviderUserInputAnswers } from "#t3tools/contracts";
+import { ProviderUserInputAnswers } from "@t3tools/contracts";
 
 import { MessageInputError } from "./error.ts";
 import type { InputError } from "./input/error.ts";

package/src/cli/model.ts

@@ -2,11 +2,13 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "./extra-args.ts";
 import { formatFlag } from "./flags.ts";
 import { T3Application } from "../application/service.ts";
-import { Environment } from "../environment/service.ts";
-import { formatModelsHuman } from "./model-format.ts";
-import { resolveOutputFormat } from "./output-format.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { formatModelsHuman } from "./format/model.ts";
+import { resolveOutputFormat } from "./format/output.ts";
 import { T3Output } from "./output/service.ts";
 
 export function createModelCommand() {
@@ -22,14 +24,16 @@ const listCommand = Command.make(
     all: Flag.boolean("all"),
     provider: Flag.string("provider").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ all, provider, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
       const providerValue = Option.getOrUndefined(provider);
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const providers = yield* application.listModels({
         all,
         ...(providerValue !== undefined && providerValue.length > 0

package/src/cli/project.ts

@@ -2,17 +2,20 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Command, Flag } from "effect/unstable/cli";
 
+import { extraArgsConfig } from "./extra-args.ts";
 import { formatFlag, projectPathFlag } from "./flags.ts";
-import { formatProjectAddedHuman, formatProjectsHuman } from "./project-format.ts";
+import { formatProjectAddedHuman, formatProjectsHuman } from "./format/project.ts";
+import { deleteProjectCommand } from "./projects/delete.ts";
 import { T3Application } from "../application/service.ts";
-import { Environment } from "../environment/service.ts";
-import { resolveOutputFormat } from "./output-format.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { resolveOutputFormat } from "./format/output.ts";
 import { T3Output } from "./output/service.ts";
 
 export function createProjectCommand() {
   return Command.make("project").pipe(
     Command.withDescription("project commands"),
-    Command.withSubcommands([listCommand, addCommand]),
+    Command.withSubcommands([listCommand, addCommand, deleteProjectCommand]),
   );
 }
 
@@ -20,13 +23,15 @@ const listCommand = Command.make(
   "list",
   {
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const snapshot = yield* application.loadShell();
       if (resolvedFormat === "json") {
         yield* output.printJson(snapshot.projects);
@@ -42,13 +47,15 @@ const addCommand = Command.make(
     path: projectPathFlag,
     title: Flag.string("title").pipe(Flag.optional),
     format: formatFlag,
+    ...extraArgsConfig,
   },
   ({ path, title, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
-      const environment = yield* Environment;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
       const output = yield* T3Output;
-      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
       const titleValue = Option.getOrUndefined(title);
       const result = yield* application.addProject({
         path,

package/src/cli/projects/delete.ts

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import { Command } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
+import { forceFlag, formatFlag, projectFlag, yesFlag } from "../flags.ts";
+import { formatProjectDeletedHuman } from "../format/project.ts";
+import { requireCommandProjectRef } from "../require.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+
+export const deleteProjectCommand = Command.make(
+  "delete",
+  {
+    project: projectFlag,
+    force: forceFlag,
+    yes: yesFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ project, force, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const projectRef = yield* requireCommandProjectRef({ project });
+      const resolvedProject = yield* application.resolveProject(projectRef);
+      yield* requireDestructiveConfirmation({
+        message: `Delete project ${resolvedProject.title} (${resolvedProject.id})?`,
+        yes,
+        cliRuntime,
+        t3CliEnv,
+      });
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      const result = yield* application.deleteProject({
+        projectId: resolvedProject.id,
+        ...(force ? { force: true } : {}),
+      });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson({
+          projectId: result.projectId,
+          dispatch: result.dispatch,
+        });
+      }
+      return yield* output.printInfo(formatProjectDeletedHuman(result));
+    }),
+).pipe(Command.withDescription("delete project"));

package/src/cli/require.ts

@@ -1,21 +1,23 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 
-import { T3Config } from "../config/service.ts";
+import { T3Config } from "../config/config.ts";
+import { loadT3CliEnv } from "../config/env/env.ts";
+import { CliRuntime } from "../cli/runtime/service.ts";
 import { ProjectLookupError } from "../domain/error.ts";
-import { resolveCommandProjectRef } from "../scope/index.ts";
+import { resolveCommandProjectRef } from "./scope/index.ts";
 
 export const requireCommandProjectRef = Effect.fn("requireCommandProjectRef")(function* (input: {
   readonly project: Option.Option<string>;
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly cwd: string;
 }) {
+  const cliRuntime = yield* CliRuntime;
+  const t3CliEnv = yield* loadT3CliEnv;
   const config = yield* T3Config;
   const resolved = yield* config.resolve();
   const ref = resolveCommandProjectRef({
     value: Option.getOrUndefined(input.project),
-    env: input.env,
-    cwd: input.cwd,
+    scope: t3CliEnv.scope,
+    cwd: cliRuntime.cwd,
     isLocal: resolved.local,
   });
   if (ref === undefined) {
@@ -23,7 +25,7 @@ export const requireCommandProjectRef = Effect.fn("requireCommandProjectRef")(fu
       new ProjectLookupError({
         message:
           "project is required: pass --project, set T3CODE_PROJECT_ROOT / T3CODE_PROJECT_ID, or use local auth",
-        ref: input.cwd,
+        ref: cliRuntime.cwd,
       }),
     );
   }

package/src/cli/runtime/index.ts

@@ -0,0 +1 @@
+export { CliRuntime, layer } from "./service.ts";

package/src/cli/runtime/service.ts

@@ -0,0 +1,28 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+export class CliRuntime extends Context.Service<
+  CliRuntime,
+  {
+    readonly cwd: string;
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+  }
+>()("t3cli/CliRuntime") {
+  static layerTest = (input?: {
+    readonly cwd?: string;
+    readonly stdoutIsTTY?: boolean;
+    readonly stderrIsTTY?: boolean;
+  }) =>
+    Layer.succeed(CliRuntime, {
+      cwd: input?.cwd ?? process.cwd(),
+      stdoutIsTTY: input?.stdoutIsTTY ?? false,
+      stderrIsTTY: input?.stderrIsTTY ?? false,
+    });
+}
+
+export const layer = Layer.succeed(CliRuntime, {
+  cwd: process.cwd(),
+  stdoutIsTTY: process.stdout.isTTY ?? false,
+  stderrIsTTY: process.stderr.isTTY ?? false,
+});

package/src/{scope → cli/scope}/resolve.ts

@@ -1,15 +1,17 @@
+import type { T3CliEnvScope } from "../../config/env/env.ts";
+
 export function resolveProjectRef(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromRoot = input.env.T3CODE_PROJECT_ROOT;
+  const fromRoot = input.scope.t3codeProjectRoot;
   if (fromRoot !== undefined && fromRoot.length > 0) {
     return fromRoot;
   }
-  const fromId = input.env.T3CODE_PROJECT_ID;
+  const fromId = input.scope.t3codeProjectId;
   if (fromId !== undefined && fromId.length > 0) {
     return fromId;
   }
@@ -18,11 +20,11 @@ export function resolveProjectRef(input: {
 
 export function resolveCommandProjectRef(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
   readonly cwd: string;
   readonly isLocal?: boolean;
 }): string | undefined {
-  const explicit = resolveProjectRef({ value: input.value, env: input.env });
+  const explicit = resolveProjectRef({ value: input.value, scope: input.scope });
   if (explicit !== undefined) {
     return explicit;
   }
@@ -34,13 +36,13 @@ export function resolveCommandProjectRef(input: {
 
 export function resolveWorktreePath(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
   readonly inferred?: string;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromEnv = input.env.T3CODE_WORKTREE_PATH;
+  const fromEnv = input.scope.t3codeWorktreePath;
   if (fromEnv !== undefined && fromEnv.length > 0) {
     return fromEnv;
   }
@@ -49,12 +51,12 @@ export function resolveWorktreePath(input: {
 
 export function resolveThreadId(input: {
   readonly value: string | undefined;
-  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly scope: T3CliEnvScope;
 }): string | undefined {
   if (input.value !== undefined && input.value.length > 0) {
     return input.value;
   }
-  const fromEnv = input.env.T3CODE_THREAD_ID;
+  const fromEnv = input.scope.t3codeThreadId;
   if (fromEnv !== undefined && fromEnv.length > 0) {
     return fromEnv;
   }

package/src/cli/terminal/attach.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command } from "effect/unstable/cli";
+
+import { T3Application } from "../../application/service.ts";
+import { extraArgsConfig } from "../extra-args.ts";
+import { threadFlag } from "../flags.ts";
+import { requireCommandThreadId } from "./scope.ts";
+import { runAttachedTerminalSession, toTerminalAttachTarget } from "./shared.ts";
+
+export const attachTerminalCommand = Command.make(
+  "attach",
+  {
+    thread: threadFlag,
+    terminalId: Argument.string("terminal-id"),
+    ...extraArgsConfig,
+  },
+  ({ thread, terminalId }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const threadId = yield* requireCommandThreadId({ thread });
+      const terminal = yield* application.getTerminal({
+        threadId,
+        terminalId,
+      });
+      yield* runAttachedTerminalSession({
+        terminal: toTerminalAttachTarget(terminal),
+      });
+    }),
+).pipe(Command.withDescription("attach to a terminal"));

package/src/cli/terminal/create.ts

@@ -0,0 +1,55 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { formatTerminalCreatedHuman } from "../format/terminal.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { formatFlag, threadFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { requireCommandThreadId } from "./scope.ts";
+import { runAttachedTerminalSession, snapshotToTerminalAttachTarget } from "./shared.ts";
+
+export const createTerminalCommand = Command.make(
+  "create",
+  {
+    thread: threadFlag,
+    command: Argument.string("command").pipe(Argument.optional),
+    id: Flag.string("id").pipe(Flag.optional),
+    attach: Flag.boolean("attach"),
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, command, id, attach, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = yield* requireCommandThreadId({ thread });
+      const terminalId = Option.getOrUndefined(id);
+      const commandValue = Option.getOrUndefined(command);
+      const snapshot = yield* application.createTerminal({
+        threadId,
+        ...(terminalId !== undefined ? { terminalId } : {}),
+        ...(commandValue !== undefined ? { command: commandValue } : {}),
+      });
+
+      if (attach) {
+        yield* runAttachedTerminalSession({
+          terminal: snapshotToTerminalAttachTarget(snapshot),
+        });
+        return;
+      }
+
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson(snapshot);
+      } else {
+        yield* output.printInfo(formatTerminalCreatedHuman(snapshot));
+      }
+    }),
+).pipe(Command.withDescription("create a terminal for a thread"));

package/src/cli/terminal/destroy.ts

@@ -0,0 +1,62 @@
+import * as Effect from "effect/Effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { extraArgsConfig } from "../extra-args.ts";
+import { requireDestructiveConfirmation } from "../interaction/confirm.ts";
+import { formatTerminalDestroyedHuman } from "../format/terminal.ts";
+import { T3Application } from "../../application/service.ts";
+import { CliRuntime } from "../../cli/runtime/service.ts";
+import { loadT3CliEnv } from "../../config/env/env.ts";
+import { formatFlag, threadFlag, yesFlag } from "../flags.ts";
+import { resolveOutputFormat } from "../format/output.ts";
+import { T3Output } from "../output/service.ts";
+import { requireCommandThreadId } from "./scope.ts";
+
+export const destroyTerminalCommand = Command.make(
+  "destroy",
+  {
+    thread: threadFlag,
+    terminalId: Argument.string("terminal-id"),
+    quiet: Flag.boolean("quiet"),
+    yes: yesFlag,
+    format: formatFlag,
+    ...extraArgsConfig,
+  },
+  ({ thread, terminalId, quiet, yes, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const cliRuntime = yield* CliRuntime;
+      const t3CliEnv = yield* loadT3CliEnv;
+      const output = yield* T3Output;
+      const threadId = yield* requireCommandThreadId({ thread });
+      yield* requireDestructiveConfirmation({
+        message: `Destroy terminal ${terminalId} in thread ${threadId} and delete its history?`,
+        yes,
+        cliRuntime,
+        t3CliEnv,
+      });
+      const terminal = {
+        threadId,
+        terminalId,
+      };
+      yield* application.destroyTerminal(terminal);
+      if (quiet) {
+        return;
+      }
+      const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
+      if (resolvedFormat === "json") {
+        yield* output.printJson({
+          threadId: terminal.threadId,
+          terminalId: terminal.terminalId,
+          destroyed: true,
+        });
+        return;
+      }
+      yield* output.printInfo(
+        formatTerminalDestroyedHuman({
+          terminalId,
+          threadId,
+        }),
+      );
+    }),
+).pipe(Command.withDescription("destroy a terminal and its history"));

package/src/cli/terminal/encoding.test.ts

@@ -0,0 +1,63 @@
+import "vite-plus/test/config";
+
+import { describe, expect, it } from "vite-plus/test";
+
+import { decodeBase64Payload, decodeHexPayload } from "./encoding.ts";
+import { filterAttachStreamEvent } from "./shared.ts";
+
+describe("terminal encoding", () => {
+  it("preserves non-utf8 bytes in hex payloads", () => {
+    expect(decodeHexPayload("ff")).toBe("\xff");
+  });
+
+  it("preserves non-utf8 bytes in base64 payloads", () => {
+    expect(decodeBase64Payload("/w==")).toBe("\xff");
+  });
+});
+
+describe("filterAttachStreamEvent", () => {
+  const snapshotEvent = {
+    type: "snapshot" as const,
+    snapshot: {
+      threadId: "thread-1",
+      terminalId: "term-1",
+      cwd: "/tmp",
+      worktreePath: null,
+      status: "running" as const,
+      pid: 1,
+      history: "hello",
+      exitCode: null,
+      exitSignal: null,
+      label: "shell",
+      updatedAt: "2026-01-01T00:00:00.000Z",
+      sequence: 3,
+    },
+  };
+
+  it("keeps snapshot history when --history is set with --from-sequence", () => {
+    const filtered = filterAttachStreamEvent(snapshotEvent, {
+      includeHistory: true,
+      fromSequence: 5,
+    });
+    expect(filtered?.type).toBe("snapshot");
+    if (filtered?.type === "snapshot") {
+      expect(filtered.snapshot.history).toBe("hello");
+    }
+  });
+
+  it("filters sequenced events inclusively from --from-sequence", () => {
+    const outputEvent = {
+      type: "output" as const,
+      threadId: "thread-1",
+      terminalId: "term-1",
+      sequence: 5,
+      data: "x",
+    };
+    expect(
+      filterAttachStreamEvent(outputEvent, { includeHistory: false, fromSequence: 5 }),
+    ).toEqual(outputEvent);
+    expect(
+      filterAttachStreamEvent(outputEvent, { includeHistory: false, fromSequence: 6 }),
+    ).toBeNull();
+  });
+});

package/src/cli/terminal/encoding.ts

@@ -0,0 +1,23 @@
+export function bytesToLatin1String(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("latin1");
+}
+
+export function decodeHexPayload(value: string): string | undefined {
+  const normalized = value.trim();
+  if (
+    normalized.length === 0 ||
+    normalized.length % 2 !== 0 ||
+    !/^[0-9a-fA-F]+$/.test(normalized)
+  ) {
+    return undefined;
+  }
+  return Buffer.from(normalized, "hex").toString("latin1");
+}
+
+export function decodeBase64Payload(value: string): string | undefined {
+  const normalized = value.trim();
+  if (normalized.length === 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) {
+    return undefined;
+  }
+  return Buffer.from(normalized, "base64").toString("latin1");
+}

package/src/cli/terminal/error.ts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+
+export class TerminalCliError extends Schema.TaggedErrorClass<TerminalCliError>()(
+  "TerminalCliError",
+  {
+    message: Schema.String,
+    threadId: Schema.optionalKey(Schema.String),
+    terminalId: Schema.optionalKey(Schema.String),
+  },
+) {}
+
+export class TerminalIoError extends Schema.TaggedErrorClass<TerminalIoError>()("TerminalIoError", {
+  message: Schema.String,
+}) {}

package/src/cli/terminal/io-node-layer.ts

@@ -0,0 +1,82 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+
+import { TerminalIoError } from "./error.ts";
+import { TerminalIo, type RawTerminalIoSession, type TerminalWindowSize } from "./io-service.ts";
+
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const INTERACTIVE_TTY_MESSAGE = "terminal attach requires an interactive TTY on stdin and stdout";
+
+const requireInteractiveTty = Effect.gen(function* () {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || process.stdin.setRawMode === undefined) {
+    return yield* Effect.fail(new TerminalIoError({ message: INTERACTIVE_TTY_MESSAGE }));
+  }
+
+  return {
+    stdin: process.stdin,
+    stdout: process.stdout,
+  };
+});
+
+export const NodeTerminalIoLive = Layer.succeed(TerminalIo, {
+  getWindowSize: requireInteractiveTty.pipe(Effect.map(readWindowSize)),
+  writeOutput: (text: string) =>
+    Effect.sync(() => {
+      process.stdout.write(text);
+    }),
+  openRawSession: Effect.acquireRelease(
+    Effect.gen(function* () {
+      const tty = yield* requireInteractiveTty;
+      const input = yield* Queue.unbounded<Uint8Array>();
+      const resize = yield* Queue.unbounded<TerminalWindowSize>();
+
+      const onResize = () => {
+        Effect.runFork(Queue.offer(resize, readWindowSize(tty)).pipe(Effect.ignore));
+      };
+
+      const onData = (chunk: Buffer | string) => {
+        Effect.runFork(
+          Queue.offer(input, typeof chunk === "string" ? Buffer.from(chunk) : chunk).pipe(
+            Effect.ignore,
+          ),
+        );
+      };
+
+      tty.stdin.resume();
+      tty.stdin.setRawMode(true);
+      process.on("SIGWINCH", onResize);
+      tty.stdin.on("data", onData);
+
+      return {
+        tty,
+        input,
+        resize,
+        onData,
+        onResize,
+        session: {
+          input: Stream.fromQueue(input),
+          resize: Stream.fromQueue(resize),
+        } satisfies RawTerminalIoSession,
+      };
+    }),
+    ({ tty, input, resize, onData, onResize }) =>
+      Effect.gen(function* () {
+        tty.stdin.off("data", onData);
+        process.off("SIGWINCH", onResize);
+        tty.stdin.setRawMode(false);
+        tty.stdin.pause();
+        yield* Queue.shutdown(input);
+        yield* Queue.shutdown(resize);
+      }),
+  ).pipe(Effect.map(({ session }) => session)),
+});
+
+function readWindowSize(tty: { readonly stdout: NodeJS.WriteStream }): TerminalWindowSize {
+  return {
+    cols: tty.stdout.columns ?? DEFAULT_COLS,
+    rows: tty.stdout.rows ?? DEFAULT_ROWS,
+  };
+}