@maria_rcks/t1code 0.0.5 → 0.0.7

package/bin/t1code.js

@@ -1,8 +1,42 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 
-import("../dist/index.mjs").catch((error) => {
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const entryPath = fileURLToPath(new URL("../dist/index.mjs", import.meta.url));
+
+function printError(error) {
   process.stderr.write(
     `${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
   );
-  process.exit(1);
-});
+}
+
+if (process.versions.bun === undefined) {
+  const child = spawn("bun", [entryPath, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.once("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 1);
+  });
+
+  child.once("error", (error) => {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      printError("t1code requires Bun on your PATH to launch the TUI runtime.");
+      process.exit(1);
+      return;
+    }
+    printError(error);
+    process.exit(1);
+  });
+} else {
+  import("../dist/index.mjs").catch((error) => {
+    printError(error);
+    process.exit(1);
+  });
+}

package/dist/index.mjs

@@ -32430,7 +32430,7 @@ var WsTransport = class {
 
 //#endregion
 //#region package.json
-var version = "0.0.5";
+var version = "0.0.7";
 
 //#endregion
 //#region src/composerAction.ts
@@ -32712,7 +32712,12 @@ const THIS_DIR = path.dirname(fileURLToPath(import.meta.url));
 const TUI_APP_DIR = path.resolve(THIS_DIR, "..");
 const REPO_ROOT = path.resolve(TUI_APP_DIR, "../..");
 const SERVER_APP_DIR = path.resolve(REPO_ROOT, "apps/server");
-const BUNDLED_SERVER_ENTRY = path.resolve(THIS_DIR, "server", "index.mjs");
+const BUNDLED_SERVER_ENTRY = path.resolve(THIS_DIR, "server", "index.js");
+function resolveBundledServerCommand(env) {
+	const configured = env.T3CODE_NODE_BIN?.trim();
+	if (configured) return configured;
+	return process.versions.bun !== void 0 ? "node" : process.execPath;
+}
 function readBooleanEnv$1(value) {
 	if (!value) return void 0;
 	const normalized = value.trim().toLowerCase();
@@ -32805,13 +32810,14 @@ async function waitForServerPort(input) {
 	throw new Error(`Timed out waiting for T3 server on ${input.host}:${input.port}.`);
 }
 function resolveServerEntry(env = process.env) {
+	const bundledServerCommand = resolveBundledServerCommand(env);
 	if (fs$1.existsSync(BUNDLED_SERVER_ENTRY)) return {
-		command: process.execPath,
+		command: bundledServerCommand,
 		args: [BUNDLED_SERVER_ENTRY]
 	};
 	const builtEntry = path.join(SERVER_APP_DIR, "dist", "index.mjs");
 	return env.NODE_ENV === "production" ? {
-		command: process.execPath,
+		command: bundledServerCommand,
 		args: [builtEntry]
 	} : {
 		command: "bun",

package/dist/server/BunPTY-tfevpp75.js

@@ -0,0 +1,114 @@
+import {
+  PtyAdapter
+} from "./index-9kq36ye2.js";
+import"./index-z7xpvjdt.js";
+import {
+  exports_Effect,
+  exports_Layer
+} from "./index-jgecjkfd.js";
+import"./index-wckvcay0.js";
+
+// src/terminal/Layers/BunPTY.ts
+class BunPtyProcess {
+  process;
+  dataListeners = new Set;
+  exitListeners = new Set;
+  decoder = new TextDecoder;
+  didExit = false;
+  constructor(process2) {
+    this.process = process2;
+    this.process.exited.then((exitCode) => {
+      this.emitExit({
+        exitCode: Number.isInteger(exitCode) ? exitCode : 0,
+        signal: typeof this.process.signalCode === "number" ? this.process.signalCode : null
+      });
+    }).catch(() => {
+      this.emitExit({ exitCode: 1, signal: null });
+    });
+  }
+  get pid() {
+    return this.process.pid;
+  }
+  write(data) {
+    if (!this.process.terminal) {
+      throw new Error("Bun PTY terminal handle is unavailable");
+    }
+    this.process.terminal.write(data);
+  }
+  resize(cols, rows) {
+    if (!this.process.terminal?.resize) {
+      throw new Error("Bun PTY resize is unavailable");
+    }
+    this.process.terminal.resize(cols, rows);
+  }
+  kill(signal) {
+    if (!signal) {
+      this.process.kill();
+      return;
+    }
+    this.process.kill(signal);
+  }
+  onData(callback) {
+    this.dataListeners.add(callback);
+    return () => {
+      this.dataListeners.delete(callback);
+    };
+  }
+  onExit(callback) {
+    this.exitListeners.add(callback);
+    return () => {
+      this.exitListeners.delete(callback);
+    };
+  }
+  emitData(data) {
+    if (this.didExit)
+      return;
+    const text = this.decoder.decode(data, { stream: true });
+    if (text.length === 0)
+      return;
+    for (const listener of this.dataListeners) {
+      listener(text);
+    }
+  }
+  emitExit(event) {
+    if (this.didExit)
+      return;
+    this.didExit = true;
+    const remainder = this.decoder.decode();
+    if (remainder.length > 0) {
+      for (const listener of this.dataListeners) {
+        listener(remainder);
+      }
+    }
+    for (const listener of this.exitListeners) {
+      listener(event);
+    }
+  }
+}
+var layer = exports_Layer.effect(PtyAdapter, exports_Effect.gen(function* () {
+  if (process.platform === "win32") {
+    return yield* exports_Effect.die("Bun PTY terminal support is unavailable on Windows. Please use Node.js (e.g. by running `npx t3`) instead.");
+  }
+  return {
+    spawn: (input) => exports_Effect.sync(() => {
+      let processHandle = null;
+      const command = [input.shell, ...input.args ?? []];
+      const subprocess = Bun.spawn(command, {
+        cwd: input.cwd,
+        env: input.env,
+        terminal: {
+          cols: input.cols,
+          rows: input.rows,
+          data: (_terminal, data) => {
+            processHandle?.emitData(data);
+          }
+        }
+      });
+      processHandle = new BunPtyProcess(subprocess);
+      return processHandle;
+    })
+  };
+}));
+export {
+  layer
+};

package/dist/server/NodePTY-shw8pxrb.js

@@ -0,0 +1,115 @@
+import {
+  PtyAdapter
+} from "./index-9kq36ye2.js";
+import"./index-z7xpvjdt.js";
+import {
+  exports_Effect,
+  exports_FileSystem,
+  exports_Layer,
+  exports_Path
+} from "./index-jgecjkfd.js";
+import {
+  __require
+} from "./index-wckvcay0.js";
+
+// src/terminal/Layers/NodePTY.ts
+import { createRequire } from "node:module";
+var didEnsureSpawnHelperExecutable = false;
+var resolveNodePtySpawnHelperPath = exports_Effect.gen(function* () {
+  const requireForNodePty = createRequire(import.meta.url);
+  const path = yield* exports_Path.Path;
+  const fs = yield* exports_FileSystem.FileSystem;
+  const packageJsonPath = requireForNodePty.resolve("node-pty/package.json");
+  const packageDir = path.dirname(packageJsonPath);
+  const candidates = [
+    path.join(packageDir, "build", "Release", "spawn-helper"),
+    path.join(packageDir, "build", "Debug", "spawn-helper"),
+    path.join(packageDir, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper")
+  ];
+  for (const candidate of candidates) {
+    if (yield* fs.exists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}).pipe(exports_Effect.orElseSucceed(() => null));
+var ensureNodePtySpawnHelperExecutable = exports_Effect.fn(function* (explicitPath) {
+  const fs = yield* exports_FileSystem.FileSystem;
+  if (process.platform === "win32")
+    return;
+  if (!explicitPath && didEnsureSpawnHelperExecutable)
+    return;
+  const helperPath = explicitPath ?? (yield* resolveNodePtySpawnHelperPath);
+  if (!helperPath)
+    return;
+  if (!explicitPath) {
+    didEnsureSpawnHelperExecutable = true;
+  }
+  if (!(yield* fs.exists(helperPath))) {
+    return;
+  }
+  yield* fs.chmod(helperPath, 493).pipe(exports_Effect.orElseSucceed(() => {
+    return;
+  }));
+});
+
+class NodePtyProcess {
+  process;
+  constructor(process2) {
+    this.process = process2;
+  }
+  get pid() {
+    return this.process.pid;
+  }
+  write(data) {
+    this.process.write(data);
+  }
+  resize(cols, rows) {
+    this.process.resize(cols, rows);
+  }
+  kill(signal) {
+    this.process.kill(signal);
+  }
+  onData(callback) {
+    const disposable = this.process.onData(callback);
+    return () => {
+      disposable.dispose();
+    };
+  }
+  onExit(callback) {
+    const disposable = this.process.onExit((event) => {
+      callback({
+        exitCode: event.exitCode,
+        signal: event.signal ?? null
+      });
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }
+}
+var layer = exports_Layer.effect(PtyAdapter, exports_Effect.gen(function* () {
+  const fs = yield* exports_FileSystem.FileSystem;
+  const path = yield* exports_Path.Path;
+  const nodePty = yield* exports_Effect.promise(() => import("node-pty"));
+  const ensureNodePtySpawnHelperExecutableCached = yield* exports_Effect.cached(ensureNodePtySpawnHelperExecutable().pipe(exports_Effect.provideService(exports_FileSystem.FileSystem, fs), exports_Effect.provideService(exports_Path.Path, path), exports_Effect.orElseSucceed(() => {
+    return;
+  })));
+  return {
+    spawn: exports_Effect.fn(function* (input) {
+      yield* ensureNodePtySpawnHelperExecutableCached;
+      const ptyProcess = nodePty.spawn(input.shell, input.args ?? [], {
+        cwd: input.cwd,
+        cols: input.cols,
+        rows: input.rows,
+        env: input.env,
+        name: globalThis.process.platform === "win32" ? "xterm-color" : "xterm-256color"
+      });
+      return new NodePtyProcess(ptyProcess);
+    })
+  };
+}));
+export {
+  layer,
+  ensureNodePtySpawnHelperExecutable
+};

package/dist/server/NodeSqliteClient-1zz4vbn2.js

@@ -0,0 +1,180 @@
+import {
+  SqlError
+} from "./index-313s4ptc.js";
+import {
+  SafeIntegers,
+  SqlClient,
+  defaultTransforms,
+  layer,
+  make as make4,
+  makeCompilerSqlite
+} from "./index-8anfbrkb.js";
+import {
+  get as get2,
+  make as make3
+} from "./index-z7xpvjdt.js";
+import {
+  Scope,
+  Service,
+  acquireUseRelease,
+  add,
+  addFinalizer1 as addFinalizer,
+  as1 as as,
+  die1 as die,
+  die2,
+  effectServices,
+  fail3 as fail,
+  flatMap1 as flatMap,
+  gen1 as gen,
+  get,
+  getCurrent,
+  getUnsafe,
+  identity,
+  make2 as make,
+  make8 as make2,
+  map6 as map,
+  minutes,
+  provide1 as provide,
+  scope1 as scope,
+  succeed4 as succeed,
+  sync1 as sync,
+  tap,
+  try_,
+  uninterruptibleMask1 as uninterruptibleMask,
+  unwrap2 as unwrap,
+  void_1 as void_,
+  withFiber1 as withFiber
+} from "./index-jgecjkfd.js";
+import"./index-wckvcay0.js";
+
+// src/persistence/NodeSqliteClient.ts
+import { DatabaseSync } from "node:sqlite";
+var ATTR_DB_SYSTEM_NAME = "db.system.name";
+var TypeId = "~local/sqlite-node/SqliteClient";
+var SqliteClient = Service("t3/persistence/NodeSqliteClient");
+var checkNodeSqliteCompat = () => {
+  const parts = process.versions.node.split(".").map(Number);
+  const major = parts[0] ?? 0;
+  const minor = parts[1] ?? 0;
+  const supported = major === 22 && minor >= 16 || major === 23 && minor >= 11 || major >= 24;
+  if (!supported) {
+    return die(`Node.js ${process.versions.node} is missing required node:sqlite APIs ` + `(StatementSync.columns). Upgrade to Node.js >=22.16, >=23.11, or >=24.`);
+  }
+  return void_;
+};
+var makeWithDatabase = (options, openDatabase) => gen(function* () {
+  yield* checkNodeSqliteCompat();
+  const compiler = makeCompilerSqlite(options.transformQueryNames);
+  const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : undefined;
+  const makeConnection = gen(function* () {
+    const scope2 = yield* scope;
+    const db = openDatabase();
+    yield* addFinalizer(scope2, sync(() => db.close()));
+    const statementReaderCache = new WeakMap;
+    const hasRows = (statement) => {
+      const cached = statementReaderCache.get(statement);
+      if (cached !== undefined) {
+        return cached;
+      }
+      const value = statement.columns().length > 0;
+      statementReaderCache.set(statement, value);
+      return value;
+    };
+    const prepareCache = yield* make3({
+      capacity: options.prepareCacheSize ?? 200,
+      timeToLive: options.prepareCacheTTL ?? minutes(10),
+      lookup: (sql) => try_({
+        try: () => db.prepare(sql),
+        catch: (cause) => new SqlError({ cause, message: "Failed to prepare statement" })
+      })
+    });
+    const runStatement = (statement, params, raw) => withFiber((fiber) => {
+      statement.setReadBigInts(Boolean(get(fiber.services, SafeIntegers)));
+      try {
+        if (hasRows(statement)) {
+          return succeed(statement.all(...params));
+        }
+        const result = statement.run(...params);
+        return succeed(raw ? result : []);
+      } catch (cause) {
+        return fail(new SqlError({ cause, message: "Failed to execute statement" }));
+      }
+    });
+    const run = (sql, params, raw = false) => flatMap(get2(prepareCache, sql), (s) => runStatement(s, params, raw));
+    const runValues = (sql, params) => acquireUseRelease(get2(prepareCache, sql), (statement) => try_({
+      try: () => {
+        if (hasRows(statement)) {
+          statement.setReturnArrays(true);
+          return statement.all(...params);
+        }
+        statement.run(...params);
+        return [];
+      },
+      catch: (cause) => new SqlError({ cause, message: "Failed to execute statement" })
+    }), (statement) => sync(() => {
+      if (hasRows(statement)) {
+        statement.setReturnArrays(false);
+      }
+    }));
+    return identity({
+      execute(sql, params, rowTransform) {
+        return rowTransform ? map(run(sql, params), rowTransform) : run(sql, params);
+      },
+      executeRaw(sql, params) {
+        return run(sql, params, true);
+      },
+      executeValues(sql, params) {
+        return runValues(sql, params);
+      },
+      executeUnprepared(sql, params, rowTransform) {
+        const effect = runStatement(db.prepare(sql), params ?? [], false);
+        return rowTransform ? map(effect, rowTransform) : effect;
+      },
+      executeStream(_sql, _params) {
+        return die2("executeStream not implemented");
+      }
+    });
+  });
+  const semaphore = yield* make2(1);
+  const connection = yield* makeConnection;
+  const acquirer = semaphore.withPermits(1)(succeed(connection));
+  const transactionAcquirer = uninterruptibleMask((restore) => {
+    const fiber = getCurrent();
+    const scope2 = getUnsafe(fiber.services, Scope);
+    return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope2, semaphore.release(1))), connection);
+  });
+  return yield* make4({
+    acquirer,
+    compiler,
+    transactionAcquirer,
+    spanAttributes: [
+      ...options.spanAttributes ? Object.entries(options.spanAttributes) : [],
+      [ATTR_DB_SYSTEM_NAME, "sqlite"]
+    ],
+    transformRows
+  });
+});
+var make5 = (options) => makeWithDatabase(options, () => new DatabaseSync(options.filename, {
+  readOnly: options.readonly ?? false,
+  allowExtension: options.allowExtension ?? false
+}));
+var makeMemory = (config = {}) => makeWithDatabase({
+  ...config,
+  filename: ":memory:",
+  readonly: false
+}, () => {
+  const database = new DatabaseSync(":memory:", {
+    allowExtension: config.allowExtension ?? false
+  });
+  return database;
+});
+var layerConfig = (config) => effectServices(unwrap(config).asEffect().pipe(flatMap(make5), map((client) => make(SqliteClient, client).pipe(add(SqlClient, client))))).pipe(provide(layer));
+var layer2 = (config) => effectServices(map(make5(config), (client) => make(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer));
+var layerMemory = (config = {}) => effectServices(map(makeMemory(config), (client) => make(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer));
+export {
+  layerMemory,
+  layerConfig,
+  layer2 as layer,
+  TypeId,
+  SqliteClient
+};

package/dist/server/SqliteClient-53018gfq.js

@@ -0,0 +1,147 @@
+import {
+  SqlError
+} from "./index-313s4ptc.js";
+import {
+  SafeIntegers,
+  SqlClient,
+  defaultTransforms,
+  layer,
+  make as make3,
+  makeCompilerSqlite
+} from "./index-8anfbrkb.js";
+import {
+  Scope,
+  Service,
+  add,
+  addFinalizer1 as addFinalizer,
+  addFinalizer2,
+  as1 as as,
+  die2 as die,
+  effectServices,
+  fail3 as fail,
+  flatMap1 as flatMap,
+  gen1 as gen,
+  get,
+  getCurrent,
+  getUnsafe,
+  identity,
+  make2 as make,
+  make8 as make2,
+  map6 as map,
+  provide1 as provide,
+  succeed4 as succeed,
+  sync1 as sync,
+  tap,
+  try_,
+  uninterruptibleMask1 as uninterruptibleMask,
+  unwrap2 as unwrap,
+  withFiber1 as withFiber
+} from "./index-jgecjkfd.js";
+import"./index-wckvcay0.js";
+
+// ../../node_modules/.bun/@effect+sql-sqlite-bun@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+sql-sqlite-bun@8881a9b+eecd35a1726d7096/node_modules/@effect/sql-sqlite-bun/dist/SqliteClient.js
+import { Database } from "bun:sqlite";
+var ATTR_DB_SYSTEM_NAME = "db.system.name";
+var TypeId = "~@effect/sql-sqlite-bun/SqliteClient";
+var SqliteClient = /* @__PURE__ */ Service("@effect/sql-sqlite-bun/Client");
+var make4 = (options) => gen(function* () {
+  const compiler = makeCompilerSqlite(options.transformQueryNames);
+  const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : undefined;
+  const makeConnection = gen(function* () {
+    const db = new Database(options.filename, {
+      readonly: options.readonly,
+      readwrite: options.readwrite ?? true,
+      create: options.create ?? true
+    });
+    yield* addFinalizer2(() => sync(() => db.close()));
+    if (options.disableWAL !== true) {
+      db.run("PRAGMA journal_mode = WAL;");
+    }
+    const run = (sql, params = []) => withFiber((fiber) => {
+      const statement = db.query(sql);
+      const useSafeIntegers = get(fiber.services, SafeIntegers);
+      statement.safeIntegers(useSafeIntegers);
+      try {
+        return succeed(statement.all(...params) ?? []);
+      } catch (cause) {
+        return fail(new SqlError({
+          cause,
+          message: "Failed to execute statement"
+        }));
+      }
+    });
+    const runValues = (sql, params = []) => withFiber((fiber) => {
+      const statement = db.query(sql);
+      const useSafeIntegers = get(fiber.services, SafeIntegers);
+      statement.safeIntegers(useSafeIntegers);
+      try {
+        return succeed(statement.values(...params) ?? []);
+      } catch (cause) {
+        return fail(new SqlError({
+          cause,
+          message: "Failed to execute statement"
+        }));
+      }
+    });
+    return identity({
+      execute(sql, params, transformRows2) {
+        return transformRows2 ? map(run(sql, params), transformRows2) : run(sql, params);
+      },
+      executeRaw(sql, params) {
+        return run(sql, params);
+      },
+      executeValues(sql, params) {
+        return runValues(sql, params);
+      },
+      executeUnprepared(sql, params, transformRows2) {
+        return this.execute(sql, params, transformRows2);
+      },
+      executeStream(_sql, _params) {
+        return die("executeStream not implemented");
+      },
+      export: try_({
+        try: () => db.serialize(),
+        catch: (cause) => new SqlError({
+          cause,
+          message: "Failed to export database"
+        })
+      }),
+      loadExtension: (path) => try_({
+        try: () => db.loadExtension(path),
+        catch: (cause) => new SqlError({
+          cause,
+          message: "Failed to load extension"
+        })
+      })
+    });
+  });
+  const semaphore = yield* make2(1);
+  const connection = yield* makeConnection;
+  const acquirer = semaphore.withPermits(1)(succeed(connection));
+  const transactionAcquirer = uninterruptibleMask((restore) => {
+    const fiber = getCurrent();
+    const scope = getUnsafe(fiber.services, Scope);
+    return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  return Object.assign(yield* make3({
+    acquirer,
+    compiler,
+    transactionAcquirer,
+    spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+    transformRows
+  }), {
+    [TypeId]: TypeId,
+    config: options,
+    export: flatMap(acquirer, (_) => _.export),
+    loadExtension: (path) => flatMap(acquirer, (_) => _.loadExtension(path))
+  });
+});
+var layerConfig = (config) => effectServices(unwrap(config).asEffect().pipe(flatMap(make4), map((client) => make(SqliteClient, client).pipe(add(SqlClient, client))))).pipe(provide(layer));
+var layer2 = (config) => effectServices(map(make4(config), (client) => make(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer));
+export {
+  make4 as make,
+  layerConfig,
+  layer2 as layer,
+  TypeId,
+  SqliteClient
+};

package/dist/server/index-313s4ptc.js

@@ -0,0 +1,18 @@
+import {
+  Defect,
+  String,
+  TaggedErrorClass,
+  optional
+} from "./index-jgecjkfd.js";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@8881a9b/node_modules/effect/dist/unstable/sql/SqlError.js
+var TypeId = "~effect/sql/SqlError";
+
+class SqlError extends (/* @__PURE__ */ TaggedErrorClass("effect/sql/SqlError")("SqlError", {
+  cause: Defect,
+  message: /* @__PURE__ */ optional(String)
+})) {
+  [TypeId] = TypeId;
+}
+
+export { SqlError };