t3code-cli 0.4.0 → 0.5.1

package/dist/src/application/layer.d.ts

@@ -772,5 +772,5 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+}, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../index.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../orchestration/service.ts").T3Orchestration>;

package/dist/src/auth/layer.d.ts

@@ -6,9 +6,11 @@ import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
+import type { AuthConfigInput } from "./type.ts";
 export declare const makeT3Auth: () => Effect.Effect<{
-    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, AuthConfigError | import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
-    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, AuthConfigError | import("./error.ts").AuthLocalError>;
+    pair: (pairingUrl: string) => Effect.Effect<import("./type.ts").PairResult, import("./error.ts").AuthPairingUrlError | import("./error.ts").AuthTransportError>;
+    local: (input: import("./type.ts").LocalAuthInput) => Effect.Effect<import("./type.ts").LocalAuthResult, import("./error.ts").AuthLocalError>;
+    writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthConfigError, never>;
     status: () => Effect.Effect<{
         readonly authenticated: boolean;
         readonly role?: "client" | "owner";

package/dist/src/auth/local-base-dir.d.ts

@@ -0,0 +1,7 @@
+import type * as Path from "effect/Path";
+import type { EnvironmentShape } from "../environment/service.ts";
+export declare function resolveLocalBaseDir(input: {
+    readonly baseDir: string | undefined;
+    readonly environment: EnvironmentShape;
+    readonly path: Path.Path;
+}): string;

package/dist/src/auth/local-origin.d.ts

@@ -0,0 +1,18 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { Environment } from "../environment/service.ts";
+import { AuthLocalError } from "./error.ts";
+import type { LocalAuthOriginInput } from "./type.ts";
+declare const T3LocalAuthOrigin_base: Context.ServiceClass<T3LocalAuthOrigin, "t3cli/T3LocalAuthOrigin", {
+    readonly resolve: (input?: LocalAuthOriginInput) => Effect.Effect<string, AuthLocalError>;
+}>;
+export declare class T3LocalAuthOrigin extends T3LocalAuthOrigin_base {
+}
+export declare const makeT3LocalAuthOrigin: () => Effect.Effect<{
+    resolve: (input?: LocalAuthOriginInput | undefined) => Effect.Effect<string, AuthLocalError, never>;
+}, never, Environment | Path.Path | FileSystem.FileSystem>;
+export declare const T3LocalAuthOriginLive: Layer.Layer<T3LocalAuthOrigin, never, Environment | Path.Path | FileSystem.FileSystem>;
+export {};

package/dist/src/auth/local-token.d.ts

@@ -0,0 +1,26 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { Environment } from "../environment/service.ts";
+import { SqlClientFactory } from "../sql/service.ts";
+import { AuthLocalError } from "./error.ts";
+import type { LocalAuthTokenInput, LocalAuthTokenResult } from "./type.ts";
+declare const T3LocalAuthToken_base: Context.ServiceClass<T3LocalAuthToken, "t3cli/T3LocalAuthToken", {
+    readonly create: (input: LocalAuthTokenInput) => Effect.Effect<LocalAuthTokenResult, AuthLocalError>;
+}>;
+export declare class T3LocalAuthToken extends T3LocalAuthToken_base {
+}
+export declare const makeT3LocalAuthToken: () => Effect.Effect<{
+    create: (input: LocalAuthTokenInput) => Effect.Effect<{
+        token: string;
+        role: "client" | "owner";
+        expiresAt: string;
+        source: "local";
+        baseDir: string;
+    }, AuthLocalError, never>;
+}, never, Environment | Path.Path | FileSystem.FileSystem | SqlClientFactory | Crypto.Crypto>;
+export declare const T3LocalAuthTokenLive: Layer.Layer<T3LocalAuthToken, never, Environment | Path.Path | FileSystem.FileSystem | SqlClientFactory | Crypto.Crypto>;
+export {};

package/dist/src/auth/local.d.ts

@@ -1,27 +1,24 @@
 import * as Context from "effect/Context";
-import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { T3Config } from "../config/service.ts";
-import { Environment } from "../environment/service.ts";
-import { SqlClientFactory } from "../sql/service.ts";
-import { AuthConfigError, AuthLocalError } from "./error.ts";
+import { AuthLocalError } from "./error.ts";
+import { T3LocalAuthOrigin } from "./local-origin.ts";
+import { T3LocalAuthToken } from "./local-token.ts";
 import type { LocalAuthInput, LocalAuthResult } from "./type.ts";
 declare const T3LocalAuth_base: Context.ServiceClass<T3LocalAuth, "t3cli/T3LocalAuth", {
-    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthConfigError | AuthLocalError>;
+    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthLocalError>;
 }>;
 export declare class T3LocalAuth extends T3LocalAuth_base {
 }
 export declare const makeT3LocalAuth: () => Effect.Effect<{
     local: (input: LocalAuthInput) => Effect.Effect<{
         url: string;
+        token: string;
         role: "client" | "owner";
         expiresAt: string;
         source: "local";
         baseDir: string;
-    }, AuthConfigError | AuthLocalError, never>;
-}, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
-export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, Environment | T3Config | SqlClientFactory | Path.Path | FileSystem.FileSystem | Crypto.Crypto>;
+    }, AuthLocalError, never>;
+}, never, T3LocalAuthOrigin | T3LocalAuthToken>;
+export declare const T3LocalAuthLive: Layer.Layer<T3LocalAuth, never, T3LocalAuthOrigin | T3LocalAuthToken>;
 export {};

package/dist/src/auth/pairing.d.ts

@@ -1,22 +1,22 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { T3Config } from "../config/service.ts";
-import { AuthConfigError, AuthPairingUrlError, AuthTransportError } from "./error.ts";
+import { AuthPairingUrlError, AuthTransportError } from "./error.ts";
 import { T3AuthTransport } from "./transport.ts";
 import type { PairingUrl, PairResult } from "./type.ts";
 declare const T3AuthPairing_base: Context.ServiceClass<T3AuthPairing, "t3cli/T3AuthPairing", {
-    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthConfigError | AuthPairingUrlError | AuthTransportError>;
+    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthPairingUrlError | AuthTransportError>;
 }>;
 export declare class T3AuthPairing extends T3AuthPairing_base {
 }
 export declare const makeT3AuthPairing: () => Effect.Effect<{
     pair: (pairingUrl: string) => Effect.Effect<{
         url: string;
+        token: string;
         role: "client" | "owner";
         expiresAt: string;
-    }, AuthPairingUrlError | AuthConfigError | AuthTransportError, never>;
-}, never, T3Config | T3AuthTransport>;
-export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3Config | T3AuthTransport>;
+    }, AuthPairingUrlError | AuthTransportError, never>;
+}, never, T3AuthTransport>;
+export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3AuthTransport>;
 export declare function parsePairingUrl(value: string): Effect.Effect<PairingUrl, AuthPairingUrlError>;
 export {};

package/dist/src/auth/service.d.ts

@@ -2,10 +2,11 @@ import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
 import type { AuthError } from "./error.ts";
-import type { LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+import type { AuthConfigInput, LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
 declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
     readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
     readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
+    readonly writeConfig: (input: AuthConfigInput) => Effect.Effect<void, AuthError>;
     readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
     readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
 }>;

package/dist/src/auth/transport.d.ts

@@ -2,16 +2,19 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { HttpClient } from "effect/unstable/http";
-import type { ResolvedConfig } from "../config/service.ts";
 import { AuthTransportError } from "./error.ts";
 import { type AuthBearerBootstrapResult, type AuthSessionState, type AuthWebSocketTicketResult } from "./schema.ts";
+export type AuthTransportConnection = {
+    readonly url: string;
+    readonly token: string;
+};
 declare const T3AuthTransport_base: Context.ServiceClass<T3AuthTransport, "t3cli/T3AuthTransport", {
     readonly bootstrapBearer: (input: {
         readonly baseUrl: string;
         readonly credential: string;
     }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
-    readonly getSession: (config: ResolvedConfig) => Effect.Effect<AuthSessionState, AuthTransportError>;
-    readonly issueWebSocketTicket: (config: ResolvedConfig) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
+    readonly getSession: (connection: AuthTransportConnection) => Effect.Effect<AuthSessionState, AuthTransportError>;
+    readonly issueWebSocketTicket: (connection: AuthTransportConnection) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
 }>;
 export declare class T3AuthTransport extends T3AuthTransport_base {
 }

package/dist/src/auth/type.d.ts

@@ -4,8 +4,13 @@ export type PairingUrl = {
     readonly baseUrl: string;
     readonly credential: string;
 };
+export type AuthConfigInput = {
+    readonly url: string;
+    readonly token: string;
+};
 export type PairResult = {
     readonly url: string;
+    readonly token: string;
     readonly role: AuthBearerBootstrapResult["role"];
     readonly expiresAt: string;
 };
@@ -16,8 +21,21 @@ export type LocalAuthInput = {
     readonly label: string;
     readonly subject: string;
 };
+export type LocalAuthTokenInput = Omit<LocalAuthInput, "origin">;
+export type LocalAuthOriginInput = {
+    readonly baseDir?: string;
+    readonly origin?: string;
+};
+export type LocalAuthTokenResult = {
+    readonly token: string;
+    readonly role: AuthSessionRole;
+    readonly expiresAt: string;
+    readonly source: "local";
+    readonly baseDir: string;
+};
 export type LocalAuthResult = {
     readonly url: string;
+    readonly token: string;
     readonly role: AuthSessionRole;
     readonly expiresAt: string;
     readonly source: "local";

package/dist/src/connection/error.d.ts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+declare const T3CodeConnectionError_base: Schema.Class<T3CodeConnectionError, Schema.TaggedStruct<"T3CodeConnectionError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+export declare class T3CodeConnectionError extends T3CodeConnectionError_base {
+}
+export {};

package/dist/src/connection/layer.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+export declare function makeT3CodeRpcLayer(): Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | import("./service.ts").T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;
+export declare const T3CodeRpcLayer: Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | import("./service.ts").T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;

package/dist/src/connection/node.d.ts

@@ -0,0 +1,2 @@
+import * as Layer from "effect/Layer";
+export declare const T3CodeNodeRpcLayer: Layer.Layer<import("../rpc/service.ts").T3Rpc, never, import("./service.ts").T3CodeConnectionProvider>;

package/dist/src/connection/service.d.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { T3CodeConnectionError } from "./error.ts";
+import type { T3CodeConnection } from "./type.ts";
+declare const T3CodeConnectionProvider_base: Context.ServiceClass<T3CodeConnectionProvider, "t3cli/T3CodeConnectionProvider", {
+    readonly get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>;
+}>;
+export declare class T3CodeConnectionProvider extends T3CodeConnectionProvider_base {
+}
+export declare function makeT3CodeConnectionProvider(get: Effect.Effect<T3CodeConnection, T3CodeConnectionError>): T3CodeConnectionProvider["Service"];
+export declare function T3CodeConnectionProviderLive(connection: T3CodeConnection): Layer.Layer<T3CodeConnectionProvider, never, never>;
+export {};

package/dist/src/connection/type.d.ts

@@ -0,0 +1,10 @@
+export type T3CodeOrigin = {
+    readonly url: string;
+};
+export type T3CodeAuth = {
+    readonly token: string;
+};
+export type T3CodeConnection = {
+    readonly origin: T3CodeOrigin;
+    readonly auth: T3CodeAuth;
+};

package/dist/src/connection.d.ts

@@ -0,0 +1,5 @@
+export { T3CodeConnectionError } from "./connection/error.ts";
+export { T3CodeRpcLayer, makeT3CodeRpcLayer } from "./connection/layer.ts";
+export { T3CodeNodeRpcLayer } from "./connection/node.ts";
+export { T3CodeConnectionProvider, T3CodeConnectionProviderLive, makeT3CodeConnectionProvider, } from "./connection/service.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection/type.ts";

package/dist/src/index.d.ts

@@ -1,6 +1,28 @@
 export { T3Application } from "./application/service.ts";
 export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent, } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
+export { T3Auth } from "./auth/service.ts";
+export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
+export { T3LocalAuthOrigin, T3LocalAuthOriginLive, makeT3LocalAuthOrigin, } from "./auth/local-origin.ts";
+export { T3LocalAuthToken, T3LocalAuthTokenLive, makeT3LocalAuthToken, } from "./auth/local-token.ts";
+export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl, } from "./auth/pairing.ts";
+export { AuthConfigError, AuthLocalDatabaseError, AuthLocalError, AuthLocalSecretError, AuthLocalSigningError, AuthPairingUrlError, AuthTransportError, } from "./auth/error.ts";
+export type { AuthError } from "./auth/error.ts";
+export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
+export type { AuthConfigInput, AuthSessionRole, LocalAuthInput, LocalAuthOriginInput, LocalAuthResult, LocalAuthTokenInput, LocalAuthTokenResult, PairingUrl, PairResult, } from "./auth/type.ts";
+export { T3Config } from "./config/service.ts";
+export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
+export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
+export { ConfigError, UrlError } from "./config/error.ts";
+export type { ConfigServiceError } from "./config/error.ts";
+export { makeT3CodeConnectionProvider, makeT3CodeRpcLayer, T3CodeConnectionProvider, T3CodeConnectionProviderLive, T3CodeNodeRpcLayer, T3CodeRpcLayer, T3CodeConnectionError, } from "./connection.ts";
+export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection.ts";
+export { Environment } from "./environment/service.ts";
+export type { EnvironmentShape } from "./environment/service.ts";
 export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer } from "./runtime.ts";
+export { AppLayer, AuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, } from "./runtime.ts";
+export { SqlClientFactory } from "./sql/service.ts";
+export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
+export { NodeSqlClientFactoryLive, NodeSqliteClientLive, makeNodeSqliteClient, } from "./sql/node-sqlite-client.ts";
 export type { OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider, } from "#t3tools/contracts";

package/dist/src/rpc/error.d.ts

@@ -2,12 +2,13 @@ import * as Schema from "effect/Schema";
 import { EnvironmentAuthorizationError, KeybindingsConfigError, OrchestrationDispatchCommandError, OrchestrationGetSnapshotError, ServerSettingsError } from "#t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
-import { AuthConfigError, AuthLocalError, AuthPairingUrlError, AuthTransportError } from "../auth/error.ts";
-import { ConfigError, UrlError } from "../config/error.ts";
+import { AuthTransportError } from "../auth/error.ts";
+import { T3CodeConnectionError } from "../connection/error.ts";
+import { UrlError } from "../config/error.ts";
 declare const RpcError_base: Schema.Class<RpcError, Schema.TaggedStruct<"RpcError", {
     readonly message: Schema.String;
     readonly method: Schema.optionalKey<Schema.String>;
-    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof RpcClientError.RpcClientError, typeof EnvironmentAuthorizationError, typeof KeybindingsConfigError, typeof OrchestrationDispatchCommandError, typeof OrchestrationGetSnapshotError, typeof ServerSettingsError, typeof AuthConfigError, typeof AuthLocalError, typeof AuthPairingUrlError, typeof AuthTransportError, typeof ConfigError, typeof HttpClientError.HttpClientErrorSchema, typeof UrlError, Schema.instanceOf<Schema.SchemaError, unknown>]>>;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof RpcClientError.RpcClientError, typeof EnvironmentAuthorizationError, typeof KeybindingsConfigError, typeof OrchestrationDispatchCommandError, typeof OrchestrationGetSnapshotError, typeof ServerSettingsError, typeof AuthTransportError, typeof T3CodeConnectionError, typeof HttpClientError.HttpClientErrorSchema, typeof UrlError, Schema.instanceOf<Schema.SchemaError, unknown>]>>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RpcError extends RpcError_base {
 }

package/dist/src/rpc/layer.d.ts

@@ -2,8 +2,9 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
-import { T3Auth } from "../auth/service.ts";
-import { T3Config } from "../config/service.ts";
+import * as Socket from "effect/unstable/socket/Socket";
+import { T3AuthTransport } from "../auth/transport.ts";
+import { T3CodeConnectionProvider } from "../connection/service.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc } from "./service.ts";
 export declare const makeT3RpcLayer: () => Effect.Effect<{
@@ -4674,5 +4675,5 @@ export declare const makeT3RpcLayer: () => Effect.Effect<{
             }[];
         }, import("effect/unstable/rpc/RpcClientError").RpcClientError | (Discard extends true ? never : import("#t3tools/contracts").EnvironmentAuthorizationError | import("#t3tools/contracts").KeybindingsConfigError | import("#t3tools/contracts").ServerSettingsError), never>;
     }, RpcError, never>;
-}, never, T3Config | Scope.Scope | T3Auth>;
-export declare const T3RpcLive: Layer.Layer<T3Rpc, never, T3Config | T3Auth>;
+}, never, Scope.Scope | T3AuthTransport | T3CodeConnectionProvider | Socket.WebSocketConstructor>;
+export declare const T3RpcLive: Layer.Layer<T3Rpc, never, T3AuthTransport | T3CodeConnectionProvider | Socket.WebSocketConstructor>;

package/dist/src/runtime.d.ts

@@ -1,3 +1,10 @@
 import * as Layer from "effect/Layer";
-export declare const AuthAppLayer: Layer.Layer<import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
-export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./config/service.ts").T3Config | import("./auth/service.ts").T3Auth | import("./orchestration/service.ts").T3Orchestration | import("./rpc/service.ts").T3Rpc, never, import("./environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+import { T3Config } from "./config/service.ts";
+export declare const T3AuthTransportLayer: Layer.Layer<import("./auth/transport.ts").T3AuthTransport, never, never>;
+export declare const T3LocalAuthOriginLayer: Layer.Layer<import("./auth/local-origin.ts").T3LocalAuthOrigin, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+export declare const T3LocalAuthTokenLayer: Layer.Layer<import("./auth/local-token.ts").T3LocalAuthToken, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const T3LocalAuthLayer: Layer.Layer<import("./auth/local.ts").T3LocalAuth, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const T3AuthPairingLayer: Layer.Layer<import("./auth/pairing.ts").T3AuthPairing, never, never>;
+export declare const T3AuthLayer: Layer.Layer<import("./index.ts").T3Auth, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AuthAppLayer: Layer.Layer<import("./index.ts").T3Auth | T3Config, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;
+export declare const AppLayer: Layer.Layer<import("./index.ts").T3Application | import("./index.ts").T3Auth | T3Config | import("./rpc/service.ts").T3Rpc | import("./orchestration/service.ts").T3Orchestration, never, import("./index.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem | import("effect/Crypto").Crypto>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "CLI for t3code",
   "keywords": [
     "claude",

package/src/auth/layer.ts

@@ -7,6 +7,7 @@ import { T3LocalAuth } from "./local.ts";
 import { T3AuthPairing } from "./pairing.ts";
 import { T3Auth } from "./service.ts";
 import { T3AuthTransport } from "./transport.ts";
+import type { AuthConfigInput } from "./type.ts";
 
 export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
   const config = yield* T3Config;
@@ -38,9 +39,25 @@ export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
     return yield* transport.issueWebSocketTicket(resolved);
   });
 
+  const writeConfig = Effect.fn("T3AuthLive.writeConfig")(function* (input: AuthConfigInput) {
+    const existing = yield* config.readStored().pipe(
+      Effect.catchTags({
+        ConfigError: (error) =>
+          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+      }),
+    );
+    yield* config.writeStored({ ...existing, url: input.url, token: input.token }).pipe(
+      Effect.catchTags({
+        ConfigError: (error) =>
+          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+      }),
+    );
+  });
+
   return {
     pair: pairing.pair,
     local: localAuth.local,
+    writeConfig,
     status,
     issueWebSocketTicket,
   };

package/src/auth/local-base-dir.ts

@@ -0,0 +1,22 @@
+import type * as Path from "effect/Path";
+
+import type { EnvironmentShape } from "../environment/service.ts";
+
+export function resolveLocalBaseDir(input: {
+  readonly baseDir: string | undefined;
+  readonly environment: EnvironmentShape;
+  readonly path: Path.Path;
+}) {
+  const envBaseDir = input.environment.env["T3CODE_HOME"];
+  const raw = input.baseDir ?? envBaseDir;
+  if (raw === undefined || raw.length === 0) {
+    return input.path.join(input.environment.homeDir, ".t3");
+  }
+  if (raw === "~") {
+    return input.environment.homeDir;
+  }
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return input.path.join(input.environment.homeDir, raw.slice(2));
+  }
+  return input.path.resolve(input.environment.cwd, raw);
+}

package/src/auth/local-origin.ts

@@ -0,0 +1,62 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+
+import { normalizeHttpBaseUrl } from "../config/url.ts";
+import { Environment } from "../environment/service.ts";
+import { AuthLocalError } from "./error.ts";
+import { resolveLocalBaseDir } from "./local-base-dir.ts";
+import { decodeAuthLocalRuntimeStateFromJson } from "./schema.ts";
+import type { LocalAuthOriginInput } from "./type.ts";
+
+export class T3LocalAuthOrigin extends Context.Service<
+  T3LocalAuthOrigin,
+  {
+    readonly resolve: (input?: LocalAuthOriginInput) => Effect.Effect<string, AuthLocalError>;
+  }
+>()("t3cli/T3LocalAuthOrigin") {}
+
+export const makeT3LocalAuthOrigin = Effect.fn("makeT3LocalAuthOrigin")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const environment = yield* Environment;
+
+  const resolve = Effect.fn("T3LocalAuthOriginLive.resolve")(function* (
+    input?: LocalAuthOriginInput,
+  ) {
+    const baseDir = resolveLocalBaseDir({ baseDir: input?.baseDir, environment, path });
+    if (input?.origin !== undefined) {
+      return yield* normalizeLocalOrigin(input.origin);
+    }
+
+    const runtimeStatePath = path.join(baseDir, "userdata", "server-runtime.json");
+    const raw = yield* fs.readFileString(runtimeStatePath).pipe(
+      Effect.mapError(
+        (error) =>
+          new AuthLocalError({
+            message: `local runtime state not found: ${runtimeStatePath}. Make sure T3 Code is running with Network access enabled, or pass --origin manually.`,
+            cause: error,
+          }),
+      ),
+    );
+    const state = yield* decodeAuthLocalRuntimeStateFromJson(raw).pipe(
+      Effect.mapError(
+        (error) =>
+          new AuthLocalError({ message: "local runtime state has invalid shape", cause: error }),
+      ),
+    );
+    return yield* normalizeLocalOrigin(state.origin);
+  });
+
+  return { resolve };
+});
+
+export const T3LocalAuthOriginLive = Layer.effect(T3LocalAuthOrigin, makeT3LocalAuthOrigin());
+
+function normalizeLocalOrigin(origin: string) {
+  return normalizeHttpBaseUrl(origin).pipe(
+    Effect.mapError((error) => new AuthLocalError({ message: error.message, cause: error })),
+  );
+}