t3code-cli 0.1.0

package/src/auth/transport.ts

@@ -0,0 +1,132 @@
+import * as Effect from "effect/Effect";
+import { HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
+
+import type { ResolvedConfig } from "../config/service.ts";
+import { AuthTransportError } from "./error.ts";
+import {
+  decodeAuthBearerBootstrapResult,
+  decodeAuthSessionState,
+  decodeAuthWebSocketTokenResult,
+} from "./schema.ts";
+
+export const makeAuthTransport = Effect.fn("makeAuthTransport")(function* () {
+  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+
+  const bootstrapBearer = Effect.fn("AuthTransport.bootstrapBearer")(function* (input: {
+    readonly baseUrl: string;
+    readonly credential: string;
+  }) {
+    const request = HttpClientRequest.post(input.baseUrl).pipe(
+      HttpClientRequest.appendUrl("/api/auth/bootstrap/bearer"),
+      HttpClientRequest.acceptJson,
+      HttpClientRequest.bodyJsonUnsafe({ credential: input.credential }),
+    );
+    const response = yield* client.execute(request).pipe(
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+      }),
+    );
+    return yield* response.json.pipe(
+      Effect.flatMap(decodeAuthBearerBootstrapResult),
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+        SchemaError: (error) =>
+          Effect.fail(
+            new AuthTransportError({ message: "auth response decode failed", cause: error }),
+          ),
+      }),
+    );
+  });
+
+  const getSession = Effect.fn("AuthTransport.getSession")(function* (config: ResolvedConfig) {
+    const request = authenticatedRequest(config, "/api/auth/session", "get");
+    const response = yield* client.execute(request).pipe(
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+      }),
+    );
+    return yield* response.json.pipe(
+      Effect.flatMap(decodeAuthSessionState),
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+        SchemaError: (error) =>
+          Effect.fail(
+            new AuthTransportError({ message: "auth response decode failed", cause: error }),
+          ),
+      }),
+    );
+  });
+
+  const issueWebSocketToken = Effect.fn("AuthTransport.issueWebSocketToken")(function* (
+    config: ResolvedConfig,
+  ) {
+    const request = authenticatedRequest(config, "/api/auth/ws-token", "post");
+    const response = yield* client.execute(request).pipe(
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+      }),
+    );
+    return yield* response.json.pipe(
+      Effect.flatMap(decodeAuthWebSocketTokenResult),
+      Effect.catchTags({
+        HttpClientError: (error) =>
+          Effect.fail(
+            new AuthTransportError({
+              message: "auth request failed",
+              cause: HttpClientError.HttpClientErrorSchema.fromHttpClientError(error),
+            }),
+          ),
+        SchemaError: (error) =>
+          Effect.fail(
+            new AuthTransportError({ message: "auth response decode failed", cause: error }),
+          ),
+      }),
+    );
+  });
+
+  return {
+    bootstrapBearer,
+    getSession,
+    issueWebSocketToken,
+  };
+});
+
+function authenticatedRequest(config: ResolvedConfig, path: string, method: "get" | "post") {
+  const request =
+    method === "get" ? HttpClientRequest.get(config.url) : HttpClientRequest.post(config.url);
+  return request.pipe(
+    HttpClientRequest.appendUrl(path),
+    HttpClientRequest.acceptJson,
+    HttpClientRequest.bearerToken(config.token),
+  );
+}

package/src/auth/type.ts

@@ -0,0 +1,31 @@
+import type { AuthBearerBootstrapResult } from "./schema.ts";
+
+export type AuthSessionRole = AuthBearerBootstrapResult["role"];
+
+export type PairingUrl = {
+  readonly baseUrl: string;
+  readonly credential: string;
+};
+
+export type PairResult = {
+  readonly url: string;
+  readonly role: AuthBearerBootstrapResult["role"];
+  readonly expiresAt: string;
+};
+
+export type LocalAuthInput = {
+  readonly baseDir?: string;
+  readonly t3Command?: string;
+  readonly origin?: string;
+  readonly role: AuthSessionRole;
+  readonly label: string;
+  readonly subject: string;
+};
+
+export type LocalAuthResult = {
+  readonly url: string;
+  readonly role: AuthSessionRole;
+  readonly expiresAt: string;
+  readonly source: "local";
+  readonly baseDir: string;
+};

package/src/bin.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Command } from "effect/unstable/cli";
+
+import { createCliCommand } from "./cli/app.ts";
+import { NodeEnvironmentLive } from "./environment/layer.ts";
+import { T3InputLive } from "./cli/input/layer.ts";
+import { T3OutputLive } from "./cli/output/layer.ts";
+import { T3Output } from "./cli/output/service.ts";
+import { AppLayer } from "./runtime.ts";
+import { T3VersionBundledLive, T3VersionPackageJsonLive } from "./version/layer.ts";
+import { T3Version } from "./version/service.ts";
+
+declare const T3CLI_VERSION: string | undefined;
+
+const VersionLive =
+  typeof T3CLI_VERSION === "string" ? T3VersionBundledLive : T3VersionPackageJsonLive;
+
+const PlatformLayer = Layer.mergeAll(NodeServices.layer, NodeEnvironmentLive);
+
+const CliLayer = Layer.mergeAll(
+  AppLayer.pipe(Layer.provide(PlatformLayer)),
+  NodeServices.layer,
+  NodeEnvironmentLive,
+  T3InputLive.pipe(Layer.provide(NodeServices.layer)),
+  T3OutputLive.pipe(Layer.provide(NodeServices.layer)),
+  VersionLive.pipe(Layer.provide(NodeServices.layer)),
+);
+
+const program = Effect.gen(function* () {
+  const version = yield* T3Version;
+  return yield* Command.run(createCliCommand(), { version: version.version });
+}).pipe(
+  Effect.tapError((error) =>
+    Effect.gen(function* () {
+      const output = yield* T3Output;
+      yield* output.writeStderr(`${error instanceof Error ? error.message : String(error)}\n`);
+    }),
+  ),
+  Effect.scoped,
+  Effect.provide(CliLayer),
+);
+
+NodeRuntime.runMain(program, { disableErrorReporting: true });

package/src/cli/app.ts

@@ -0,0 +1,18 @@
+import { Command } from "effect/unstable/cli";
+
+import { createAuthCommand } from "./auth.ts";
+import { createModelsCommand } from "./models.ts";
+import { createProjectsCommand } from "./projects.ts";
+import { createThreadsCommand } from "./threads.ts";
+
+export function createCliCommand() {
+  return Command.make("t3cli").pipe(
+    Command.withDescription("non-interactive cli for running t3code server"),
+    Command.withSubcommands([
+      createAuthCommand(),
+      createModelsCommand(),
+      createProjectsCommand(),
+      createThreadsCommand(),
+    ]),
+  );
+}

package/src/cli/auth-format.ts

@@ -0,0 +1,43 @@
+import type { AuthSessionState } from "../auth/schema.ts";
+import type { ResolvedConfig } from "../config/service.ts";
+import type { LocalAuthResult, PairResult } from "../auth/type.ts";
+
+export function formatAuthPaired(result: PairResult) {
+  return `paired: ${result.url}\nrole: ${result.role}\nexpires: ${result.expiresAt}`;
+}
+
+export function formatAuthLocalHuman(result: LocalAuthResult) {
+  return [
+    `paired: ${result.url}`,
+    `role: ${result.role}`,
+    `expires: ${result.expiresAt}`,
+    `baseDir: ${result.baseDir}`,
+  ].join("\n");
+}
+
+export function formatAuthLocalJson(result: LocalAuthResult) {
+  return result;
+}
+
+export function formatAuthStatusHuman(input: {
+  readonly config: ResolvedConfig;
+  readonly result: AuthSessionState;
+}) {
+  return [
+    `url: ${input.config.url}`,
+    `authenticated: ${input.result.authenticated ? "yes" : "no"}`,
+    ...(input.result.role !== undefined ? [`role: ${input.result.role}`] : []),
+    ...(input.result.expiresAt !== undefined ? [`expires: ${input.result.expiresAt}`] : []),
+  ].join("\n");
+}
+
+export function formatAuthStatusJson(input: {
+  readonly config: ResolvedConfig;
+  readonly result: AuthSessionState;
+}) {
+  return {
+    ...input.result,
+    url: input.config.url,
+    source: input.config.source,
+  };
+}

package/src/cli/auth.ts

@@ -0,0 +1,99 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import {
+  formatAuthLocalHuman,
+  formatAuthLocalJson,
+  formatAuthPaired,
+  formatAuthStatusHuman,
+  formatAuthStatusJson,
+} from "./auth-format.ts";
+import { T3Auth } from "../auth/service.ts";
+import { T3Config } from "../config/service.ts";
+import { Environment } from "../environment/service.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { T3Output } from "./output/service.ts";
+
+export function createAuthCommand() {
+  return Command.make("auth").pipe(
+    Command.withDescription("auth commands"),
+    Command.withSubcommands([pairCommand, localCommand, statusCommand]),
+  );
+}
+
+const pairCommand = Command.make(
+  "pair",
+  {
+    url: Argument.string("url"),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ url, format }) =>
+    Effect.gen(function* () {
+      const auth = yield* T3Auth;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* auth.pair(url);
+      if (resolvedFormat === "json") {
+        yield* output.printJson(result);
+      } else {
+        yield* output.printInfo(formatAuthPaired(result));
+      }
+    }),
+).pipe(Command.withDescription("pair with t3code server"));
+
+const localCommand = Command.make(
+  "local",
+  {
+    baseDir: Flag.string("base-dir").pipe(Flag.optional),
+    t3Command: Flag.string("t3-command").pipe(Flag.optional),
+    origin: Flag.string("origin").pipe(Flag.optional),
+    role: Flag.choice("role", ["owner", "client"] as const).pipe(Flag.withDefault("owner")),
+    label: Flag.string("label").pipe(Flag.withDefault("t3cli")),
+    subject: Flag.string("subject").pipe(Flag.withDefault("t3cli-local")),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ baseDir, t3Command, origin, role, label, subject, format }) =>
+    Effect.gen(function* () {
+      const auth = yield* T3Auth;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* auth.local({
+        role,
+        label,
+        subject,
+        ...(Option.isSome(t3Command) ? { t3Command: t3Command.value } : {}),
+        ...(Option.isSome(baseDir) ? { baseDir: baseDir.value } : {}),
+        ...(Option.isSome(origin) ? { origin: origin.value } : {}),
+      });
+      if (resolvedFormat === "json") {
+        yield* output.printJson(formatAuthLocalJson(result));
+      } else {
+        yield* output.printInfo(formatAuthLocalHuman(result));
+      }
+    }),
+).pipe(Command.withDescription("authenticate with local t3code installation"));
+
+const statusCommand = Command.make(
+  "status",
+  {
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ format }) =>
+    Effect.gen(function* () {
+      const configService = yield* T3Config;
+      const auth = yield* T3Auth;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const config = yield* configService.resolve();
+      const result = yield* auth.status();
+      if (resolvedFormat === "json") {
+        yield* output.printJson(formatAuthStatusJson({ config, result }));
+      } else {
+        yield* output.printInfo(formatAuthStatusHuman({ config, result }));
+      }
+    }),
+).pipe(Command.withDescription("show auth status"));

package/src/cli/error.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+
+export class MessageInputError extends Schema.TaggedErrorClass<MessageInputError>()(
+  "MessageInputError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class InvalidLimitError extends Schema.TaggedErrorClass<InvalidLimitError>()(
+  "InvalidLimitError",
+  {
+    message: Schema.String,
+    value: Schema.String,
+  },
+) {}

package/src/cli/input/error.ts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+const PlatformErrorCauseSchema = Schema.Struct({
+  _tag: Schema.Literal("PlatformError"),
+  message: Schema.String,
+});
+
+export class InputError extends Schema.TaggedErrorClass<InputError>()("InputError", {
+  message: Schema.String,
+  cause: Schema.optionalKey(PlatformErrorCauseSchema),
+}) {}

package/src/cli/input/layer.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stdio from "effect/Stdio";
+import * as Stream from "effect/Stream";
+
+import { InputError } from "./error.ts";
+import { T3Input } from "./service.ts";
+
+export const makeT3Input = Effect.fn("makeT3Input")(function* () {
+  const stdio = yield* Stdio.Stdio;
+
+  const readStdin = Effect.fn("T3InputLive.readStdin")(function* () {
+    return yield* stdio.stdin.pipe(
+      Stream.decodeText(),
+      Stream.runFold(
+        () => "",
+        (acc, chunk) => acc + chunk,
+      ),
+      Effect.catchTags({
+        PlatformError: (error) =>
+          Effect.fail(new InputError({ message: "failed to read stdin", cause: error })),
+      }),
+    );
+  });
+
+  return {
+    readStdin,
+  };
+});
+
+export const T3InputLive = Layer.effect(T3Input, makeT3Input());

package/src/cli/input/service.ts

@@ -0,0 +1,11 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+
+import type { InputError } from "./error.ts";
+
+export class T3Input extends Context.Service<
+  T3Input,
+  {
+    readonly readStdin: () => Effect.Effect<string, InputError>;
+  }
+>()("t3cli/T3Input") {}

package/src/cli/message-input.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+
+import { MessageInputError } from "./error.ts";
+import type { InputError } from "./input/error.ts";
+
+export function readInitialMessage(input: {
+  readonly message: string | undefined;
+  readonly fromStdin: boolean;
+  readonly readStdin: () => Effect.Effect<string, InputError>;
+}) {
+  if (input.message !== undefined && input.message.length > 0 && input.fromStdin) {
+    return Effect.fail(
+      new MessageInputError({ message: "pass message argument or --stdin, not both" }),
+    );
+  }
+  if (input.fromStdin) {
+    return input.readStdin();
+  }
+  if (input.message === undefined || input.message.length === 0) {
+    return Effect.fail(
+      new MessageInputError({ message: "message required unless --stdin is used" }),
+    );
+  }
+  return Effect.succeed(input.message);
+}

package/src/cli/model-format.ts

@@ -0,0 +1,18 @@
+import type { ServerProvider } from "../domain/schema.ts";
+
+export function formatModelsHuman(providers: ReadonlyArray<ServerProvider>) {
+  if (providers.length === 0) {
+    return "no models found\n";
+  }
+  return providers
+    .map((provider) => {
+      const models = provider.models;
+      const displayName = provider.displayName ?? provider.instanceId;
+      const header = `${displayName} (${provider.instanceId}) - ${provider.status}`;
+      if (models.length === 0) {
+        return `${header}\n  no models`;
+      }
+      return [header, ...models.map((model) => `  ${model.slug} - ${model.name}`)].join("\n");
+    })
+    .join("\n\n");
+}

package/src/cli/model-options.ts

@@ -0,0 +1,56 @@
+import * as Option from "effect/Option";
+
+type ModelOptionValue = string | boolean;
+
+export type ModelOption = {
+  readonly id: string;
+  readonly value: ModelOptionValue;
+};
+
+export function buildModelOptions(input: {
+  readonly option: Option.Option<Record<string, string>>;
+  readonly reasoningEffort: Option.Option<string>;
+  readonly effort: Option.Option<string>;
+  readonly fastMode: Option.Option<boolean>;
+  readonly thinking: Option.Option<boolean>;
+}): ReadonlyArray<ModelOption> {
+  const options = new Map<string, ModelOption>();
+  const optionRecord = Option.getOrUndefined(input.option);
+  if (optionRecord !== undefined) {
+    for (const [id, value] of Object.entries(optionRecord)) {
+      options.set(id, { id, value: parseModelOptionValue(value) });
+    }
+  }
+  setStringOption(options, "reasoningEffort", Option.getOrUndefined(input.reasoningEffort));
+  setStringOption(options, "effort", Option.getOrUndefined(input.effort));
+  setBooleanOption(options, "fastMode", Option.getOrUndefined(input.fastMode));
+  setBooleanOption(options, "thinking", Option.getOrUndefined(input.thinking));
+  return [...options.values()];
+}
+
+function parseModelOptionValue(value: string): ModelOptionValue {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  return value;
+}
+
+function setStringOption(options: Map<string, ModelOption>, id: string, value: string | undefined) {
+  if (value !== undefined && value.length > 0) {
+    options.set(id, { id, value });
+  }
+}
+
+function setBooleanOption(
+  options: Map<string, ModelOption>,
+  id: string,
+  value: boolean | undefined,
+) {
+  if (value !== undefined) {
+    options.set(id, { id, value });
+  }
+}

package/src/cli/models.ts

@@ -0,0 +1,45 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { T3Application } from "../application/service.ts";
+import { Environment } from "../environment/service.ts";
+import { formatModelsHuman } from "./model-format.ts";
+import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { T3Output } from "./output/service.ts";
+
+export function createModelsCommand() {
+  return Command.make("models").pipe(
+    Command.withDescription("model commands"),
+    Command.withSubcommands([listCommand]),
+  );
+}
+
+const listCommand = Command.make(
+  "list",
+  {
+    all: Flag.boolean("all"),
+    provider: Flag.string("provider").pipe(Flag.optional),
+    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+  },
+  ({ all, provider, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const providerValue = Option.getOrUndefined(provider);
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const providers = yield* application.listModels({
+        all,
+        ...(providerValue !== undefined && providerValue.length > 0
+          ? { provider: providerValue }
+          : {}),
+      });
+
+      if (resolvedFormat === "json") {
+        yield* output.printJson(providers);
+      } else {
+        yield* output.writeStdout(formatModelsHuman(providers));
+      }
+    }),
+).pipe(Command.withDescription("list provider models"));

package/src/cli/output/error.ts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+const PlatformErrorCauseSchema = Schema.Struct({
+  _tag: Schema.Literal("PlatformError"),
+  message: Schema.String,
+});
+
+export class OutputError extends Schema.TaggedErrorClass<OutputError>()("OutputError", {
+  message: Schema.String,
+  cause: Schema.optionalKey(PlatformErrorCauseSchema),
+}) {}

package/src/cli/output/layer.ts

@@ -0,0 +1,53 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stdio from "effect/Stdio";
+import * as Stream from "effect/Stream";
+
+import { OutputError } from "./error.ts";
+import { T3Output } from "./service.ts";
+
+export const makeT3Output = Effect.fn("makeT3Output")(function* () {
+  const stdio = yield* Stdio.Stdio;
+
+  const writeStdout = Effect.fn("T3OutputLive.writeStdout")(function* (text: string) {
+    yield* Stream.succeed(text).pipe(
+      Stream.run(stdio.stdout()),
+      Effect.catchTags({
+        PlatformError: (error) =>
+          Effect.fail(new OutputError({ message: "failed to write output", cause: error })),
+      }),
+    );
+  });
+
+  const writeStderr = Effect.fn("T3OutputLive.writeStderr")(function* (text: string) {
+    yield* Stream.succeed(text).pipe(
+      Stream.run(stdio.stderr()),
+      Effect.catchTags({
+        PlatformError: (error) =>
+          Effect.fail(new OutputError({ message: "failed to write output", cause: error })),
+      }),
+    );
+  });
+
+  const printJson = Effect.fn("T3OutputLive.printJson")(function* (value: unknown) {
+    yield* writeStdout(`${JSON.stringify(value, null, 2)}\n`);
+  });
+
+  const printNdjson = Effect.fn("T3OutputLive.printNdjson")(function* (value: unknown) {
+    yield* writeStdout(`${JSON.stringify(value)}\n`);
+  });
+
+  const printInfo = Effect.fn("T3OutputLive.printInfo")(function* (message: string) {
+    yield* writeStdout(`${message}\n`);
+  });
+
+  return {
+    writeStdout,
+    writeStderr,
+    printJson,
+    printNdjson,
+    printInfo,
+  };
+});
+
+export const T3OutputLive = Layer.effect(T3Output, makeT3Output());

package/src/cli/output/service.ts

@@ -0,0 +1,15 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+
+import type { OutputError } from "./error.ts";
+
+export class T3Output extends Context.Service<
+  T3Output,
+  {
+    readonly writeStdout: (text: string) => Effect.Effect<void, OutputError>;
+    readonly writeStderr: (text: string) => Effect.Effect<void, OutputError>;
+    readonly printJson: (value: unknown) => Effect.Effect<void, OutputError>;
+    readonly printNdjson: (value: unknown) => Effect.Effect<void, OutputError>;
+    readonly printInfo: (message: string) => Effect.Effect<void, OutputError>;
+  }
+>()("t3cli/T3Output") {}