@t3x-dev/local 0.1.2

package/dist/chunk-KNAXB6AU.js

@@ -0,0 +1,573 @@
+import {
+  clearRuntimeState,
+  ensureRuntimeMetadataDirs,
+  formatMissingArtifacts,
+  getLocalPaths,
+  getMissingStartArtifacts,
+  getRuntimeProcessStatus,
+  readRuntimeState,
+  spawnNodeScript,
+  terminateProcess,
+  writeRuntimeState
+} from "./chunk-E4LL4ESG.js";
+
+// src/commands/start.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+
+// src/runtime/env.ts
+import path from "path";
+var DEFAULT_API_PORT = 8e3;
+var DEFAULT_WEB_PORT = 3e3;
+function resolveStartOptions(input, paths, baseEnv = process.env) {
+  const apiPort = input.apiPort ?? DEFAULT_API_PORT;
+  const webPort = input.webPort ?? DEFAULT_WEB_PORT;
+  validatePort(apiPort, "API");
+  validatePort(webPort, "Web");
+  if (apiPort === webPort) {
+    throw new Error("[t3x-local] API port and Web port must be different");
+  }
+  return {
+    dataDir: path.resolve(input.dataDir ?? baseEnv.T3X_DATA_DIR ?? paths.defaultDataDir),
+    apiPort,
+    webPort
+  };
+}
+function buildApiEnv(baseEnv, options) {
+  return {
+    ...baseEnv,
+    NODE_ENV: "development",
+    PORT: String(options.apiPort),
+    AUTH_DISABLED: "true",
+    NEXT_PUBLIC_AUTH_DISABLED: "true",
+    T3X_DATA_DIR: options.dataDir
+  };
+}
+function buildWebEnv(baseEnv, options) {
+  return {
+    ...baseEnv,
+    NODE_ENV: "production",
+    PORT: String(options.webPort),
+    HOSTNAME: "0.0.0.0",
+    AUTH_DISABLED: "true",
+    NEXT_PUBLIC_AUTH_DISABLED: "true",
+    NEXT_PUBLIC_API_URL: `http://localhost:${options.apiPort}`
+  };
+}
+function validatePort(port, label) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`[t3x-local] ${label} port must be an integer between 1 and 65535`);
+  }
+}
+
+// src/runtime/health.ts
+async function waitForHttpOk(url, options) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const intervalMs = options.intervalMs ?? 500;
+  const startedAt = Date.now();
+  let lastError = null;
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return;
+      }
+      lastError = `HTTP ${response.status}`;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error(
+    `${options.label} did not become healthy at ${url} within ${timeoutMs}ms` + (lastError ? ` (last error: ${lastError})` : "")
+  );
+}
+async function checkHttpHealth(url, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    return {
+      ok: response.ok,
+      details: `HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      details: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/runtime/ports.ts
+import net from "net";
+async function getPortStatus(port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({
+      host: "127.0.0.1",
+      port
+    });
+    socket.setTimeout(1500);
+    socket.once("connect", () => {
+      socket.end();
+      resolve({
+        port,
+        available: false,
+        details: "occupied"
+      });
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve({
+        port,
+        available: false,
+        details: "timeout"
+      });
+    });
+    socket.once("error", (error) => {
+      if (error.code === "ECONNREFUSED") {
+        resolve({
+          port,
+          available: true,
+          details: "available"
+        });
+        return;
+      }
+      resolve({
+        port,
+        available: false,
+        details: error.code ?? error.message
+      });
+    });
+  });
+}
+async function assertPortAvailable(port, label) {
+  const status = await getPortStatus(port);
+  if (!status.available) {
+    throw new Error(
+      `[t3x-local] ${label} port ${port} is already in use (${status.details}). Choose a different port or stop the conflicting process first.`
+    );
+  }
+}
+
+// src/runtime/version-check.ts
+import fs from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+var require2 = createRequire(import.meta.url);
+var FIXED_VERSION_PACKAGES = [
+  "@t3x-dev/yops",
+  "@t3x-dev/yschema",
+  "@t3x-dev/core",
+  "@t3x-dev/storage",
+  "@t3x-dev/api",
+  "@t3x-dev/api-client",
+  "@t3x-dev/cli",
+  "@t3x-dev/mcp",
+  "@t3x-dev/local"
+];
+var FIXED_PACKAGE_WORKSPACE_PATHS = {
+  "@t3x-dev/yops": path2.join("packages", "yops", "package.json"),
+  "@t3x-dev/yschema": path2.join("packages", "yschema", "package.json"),
+  "@t3x-dev/core": path2.join("packages", "core", "package.json"),
+  "@t3x-dev/storage": path2.join("packages", "storage", "package.json"),
+  "@t3x-dev/api": path2.join("packages", "api", "package.json"),
+  "@t3x-dev/api-client": path2.join("packages", "api-client", "package.json"),
+  "@t3x-dev/cli": path2.join("apps", "cli", "package.json"),
+  "@t3x-dev/mcp": path2.join("apps", "mcp", "package.json"),
+  "@t3x-dev/local": path2.join("apps", "local", "package.json")
+};
+var LOCAL_DIRECT_FIXED_DEPENDENCIES = [
+  "@t3x-dev/api",
+  "@t3x-dev/cli",
+  "@t3x-dev/mcp",
+  "@t3x-dev/storage"
+];
+function getVersionSnapshot(paths) {
+  const report = getVersionLockReport(paths);
+  const manifestVersions = readManifestDependencyVersions(paths);
+  return {
+    node: process.version,
+    platform: `${process.platform}-${process.arch}`,
+    local: report.resolvedVersions["@t3x-dev/local"] ?? "unknown",
+    api: report.resolvedVersions["@t3x-dev/api"] ?? "unknown",
+    web: manifestVersions.web ?? (paths.repoRoot ? readPackageVersion(path2.join(paths.repoRoot, "apps", "web", "package.json")) : "runtime-only"),
+    cli: report.resolvedVersions["@t3x-dev/cli"] ?? "unknown",
+    mcp: report.resolvedVersions["@t3x-dev/mcp"] ?? "unknown",
+    fixedVersion: report.expectedVersion
+  };
+}
+function getVersionLockReport(paths) {
+  const localPackageJsonPath = path2.join(paths.packageDir, "package.json");
+  const localPackageJson = readPackageJson(localPackageJsonPath);
+  const manifest = readRuntimeManifest(paths);
+  const expectedVersion = localPackageJson.version ?? "unknown";
+  const problems = [];
+  const resolvedVersions = {};
+  for (const dependencyName of LOCAL_DIRECT_FIXED_DEPENDENCIES) {
+    const actual = localPackageJson.dependencies?.[dependencyName];
+    if (actual !== expectedVersion && actual !== `workspace:${expectedVersion}`) {
+      problems.push(
+        `Local package dependency ${dependencyName} must pin ${expectedVersion}, found ${actual ?? "missing"}`
+      );
+    }
+  }
+  if (manifest) {
+    if (manifest.packageVersion !== expectedVersion) {
+      problems.push(
+        `runtime-manifest.json packageVersion must be ${expectedVersion}, found ${manifest.packageVersion ?? "missing"}`
+      );
+    }
+    for (const packageName of FIXED_VERSION_PACKAGES) {
+      const manifestVersion = manifest.dependencies?.[packageName];
+      if (manifestVersion !== expectedVersion) {
+        problems.push(
+          `runtime-manifest.json dependency ${packageName} must be ${expectedVersion}, found ${manifestVersion ?? "missing"}`
+        );
+      }
+    }
+  }
+  for (const packageName of FIXED_VERSION_PACKAGES) {
+    const actualVersion = packageName === "@t3x-dev/local" ? expectedVersion : resolveFixedPackageVersion(packageName, paths, manifest);
+    resolvedVersions[packageName] = actualVersion ?? "unknown";
+    if (!actualVersion) {
+      problems.push(`Could not resolve installed version for ${packageName}`);
+      continue;
+    }
+    if (actualVersion !== expectedVersion) {
+      problems.push(
+        `${packageName} must use fixed version ${expectedVersion}, found ${actualVersion}`
+      );
+    }
+  }
+  return {
+    expectedVersion,
+    resolvedVersions,
+    problems
+  };
+}
+function assertVersionLockOrThrow(paths, context) {
+  const report = getVersionLockReport(paths);
+  if (report.problems.length > 0) {
+    throw new Error(
+      `[t3x-local] Version lock check failed during ${context}.
+` + report.problems.map((problem) => `- ${problem}`).join("\n")
+    );
+  }
+  return report;
+}
+function resolveFixedPackageVersion(packageName, paths, manifest) {
+  const installedPackageJsonPath = findInstalledPackageJson(packageName);
+  if (installedPackageJsonPath) {
+    return readPackageVersion(installedPackageJsonPath);
+  }
+  if (paths.repoRoot) {
+    return readPackageVersion(
+      path2.join(paths.repoRoot, FIXED_PACKAGE_WORKSPACE_PATHS[packageName])
+    );
+  }
+  return manifest?.dependencies?.[packageName] ?? null;
+}
+function readRuntimeManifest(paths) {
+  if (!fs.existsSync(paths.runtimeManifestPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(paths.runtimeManifestPath, "utf8"));
+}
+function readManifestDependencyVersions(paths) {
+  return readRuntimeManifest(paths)?.dependencies ?? {};
+}
+function findInstalledPackageJson(packageName) {
+  try {
+    const entryPath = require2.resolve(packageName);
+    let current = path2.dirname(entryPath);
+    while (current !== path2.dirname(current)) {
+      const packageJsonPath = path2.join(current, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        if (packageJson.name === packageName) {
+          return packageJsonPath;
+        }
+      }
+      current = path2.dirname(current);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readPackageJson(packageJsonPath) {
+  return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+function readPackageVersion(packageJsonPath) {
+  return readPackageJson(packageJsonPath).version ?? "unknown";
+}
+
+// src/commands/start.ts
+var TEXT_RUNTIME_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".js", ".json", ".mjs"]);
+var BAKED_API_URL_PATTERNS = [
+  {
+    from: "http://localhost:8000",
+    to: (apiPort) => `http://localhost:${apiPort}`
+  },
+  {
+    from: "http://127.0.0.1:8000",
+    to: (apiPort) => `http://127.0.0.1:${apiPort}`
+  }
+];
+async function runStartCommand(input = {}) {
+  const paths = getLocalPaths();
+  assertVersionLockOrThrow(paths, "t3x-local start");
+  const options = resolveStartOptions(input, paths, process.env);
+  const missing = getMissingStartArtifacts(paths);
+  if (missing.length > 0) {
+    throw new Error(formatMissingArtifacts(missing, paths));
+  }
+  const existingState = await readRuntimeState(paths);
+  if (existingState) {
+    const status = getRuntimeProcessStatus(existingState);
+    if (status.apiRunning || status.webRunning) {
+      throw new Error(
+        `[t3x-local] Local runtime is already running. API pid=${existingState.apiPid}, Web pid=${existingState.webPid}. Run \`t3x-local doctor\` or \`t3x-local stop\` first.`
+      );
+    }
+    await clearRuntimeState(paths);
+  }
+  await Promise.all([
+    assertPortAvailable(options.apiPort, "API"),
+    assertPortAvailable(options.webPort, "Web")
+  ]);
+  const metadataPaths = await ensureRuntimeMetadataDirs(paths);
+  let apiProcess = null;
+  let webProcess = null;
+  try {
+    await prepareWebRuntime(paths, options);
+    apiProcess = spawnApi(paths, options, metadataPaths.apiLogPath);
+    webProcess = spawnWeb(paths, options, metadataPaths.webLogPath);
+    if (!apiProcess.child.pid || !webProcess.child.pid) {
+      throw new Error("[t3x-local] Failed to capture child process IDs for the local runtime");
+    }
+    const runtimeState = buildRuntimeState(
+      options,
+      metadataPaths.apiLogPath,
+      metadataPaths.webLogPath,
+      {
+        apiPid: apiProcess.child.pid,
+        webPid: webProcess.child.pid
+      }
+    );
+    await clearRuntimeState(paths);
+    await Promise.all([
+      writeRuntimeState(paths, runtimeState),
+      waitForHttpOk(runtimeState.apiHealthUrl, { label: "API" }),
+      waitForHttpOk(runtimeState.webHealthUrl, { label: "Web" })
+    ]);
+    console.log(`[t3x-local] Started API pid ${runtimeState.apiPid} at ${runtimeState.apiUrl}`);
+    console.log(`[t3x-local] Started Web pid ${runtimeState.webPid} at ${runtimeState.webUrl}`);
+    console.log(`[t3x-local] Data dir: ${runtimeState.dataDir}`);
+    console.log(`[t3x-local] State file: ${metadataPaths.stateFilePath}`);
+    console.log(`[t3x-local] Logs: ${metadataPaths.apiLogPath} | ${metadataPaths.webLogPath}`);
+  } catch (error) {
+    await Promise.all([
+      apiProcess ? terminateProcess(apiProcess) : Promise.resolve(),
+      webProcess ? terminateProcess(webProcess) : Promise.resolve(),
+      clearRuntimeState(paths)
+    ]);
+    throw error;
+  }
+}
+function buildRuntimeState(options, apiLogPath, webLogPath, pids) {
+  return {
+    schemaVersion: 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dataDir: options.dataDir,
+    apiPort: options.apiPort,
+    webPort: options.webPort,
+    apiPid: pids.apiPid,
+    webPid: pids.webPid,
+    apiUrl: `http://localhost:${options.apiPort}`,
+    webUrl: `http://localhost:${options.webPort}`,
+    apiHealthUrl: `http://127.0.0.1:${options.apiPort}/health`,
+    webHealthUrl: `http://127.0.0.1:${options.webPort}/health`,
+    apiLogPath,
+    webLogPath
+  };
+}
+function spawnApi(paths, options, logPath) {
+  console.log("[t3x-local] Starting API...");
+  return spawnNodeScript({
+    name: "api",
+    entryPath: paths.apiEntryPath,
+    cwd: paths.repoRoot ?? paths.packageDir,
+    detached: true,
+    env: buildApiEnv(process.env, options),
+    stderrPath: logPath,
+    stdoutPath: logPath
+  });
+}
+function spawnWeb(paths, options, logPath) {
+  console.log("[t3x-local] Starting Web...");
+  const runtimeDir = `${paths.localRuntimeRoot}/web`;
+  const webEntryPath = `${runtimeDir}/apps/web/server.js`;
+  return spawnNodeScript({
+    name: "web",
+    entryPath: webEntryPath,
+    cwd: runtimeDir,
+    detached: true,
+    env: buildWebEnv(process.env, options),
+    stderrPath: logPath,
+    stdoutPath: logPath
+  });
+}
+async function prepareWebRuntime(paths, options) {
+  const runtimeDir = `${paths.localRuntimeRoot}/web`;
+  const runtimeNextDir = `${runtimeDir}/apps/web/.next`;
+  await fs2.rm(runtimeDir, { recursive: true, force: true });
+  await fs2.cp(paths.webStandaloneDir, runtimeDir, {
+    recursive: true,
+    verbatimSymlinks: true
+  });
+  await fs2.mkdir(runtimeNextDir, { recursive: true });
+  await fs2.cp(paths.webStaticDir, `${runtimeNextDir}/static`, { recursive: true });
+  await fs2.cp(paths.webPublicDir, `${runtimeDir}/apps/web/public`, { recursive: true });
+  const rewriteStats = await rewriteBakedWebApiUrls(runtimeDir, options.apiPort);
+  validateRewriteOutcome(rewriteStats, options.apiPort);
+  await assertNoBakedApiUrlResidue(runtimeDir, options.apiPort);
+  if (rewriteStats.replacements > 0) {
+    console.log(
+      `[t3x-local] Rewrote ${rewriteStats.replacements} baked Web API URL occurrence(s) across ${rewriteStats.filesUpdated} file(s).`
+    );
+  }
+}
+async function rewriteBakedWebApiUrls(runtimeDir, apiPort) {
+  const stats = {
+    filesScanned: 0,
+    filesUpdated: 0,
+    replacements: 0
+  };
+  await rewriteRuntimeTree(runtimeDir, apiPort, stats);
+  return stats;
+}
+async function rewriteRuntimeTree(currentDir, apiPort, stats) {
+  const entries = await fs2.readdir(currentDir, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = path3.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await rewriteRuntimeTree(entryPath, apiPort, stats);
+        return;
+      }
+      if (!shouldRewriteRuntimeFile(entryPath)) {
+        return;
+      }
+      stats.filesScanned += 1;
+      const original = await fs2.readFile(entryPath, "utf8");
+      const rewritten = replaceBakedApiUrls(original, apiPort);
+      if (rewritten === original) {
+        return;
+      }
+      stats.filesUpdated += 1;
+      stats.replacements += countApiUrlReplacements(original, apiPort);
+      await fs2.writeFile(entryPath, rewritten);
+    })
+  );
+}
+function shouldRewriteRuntimeFile(filePath) {
+  return TEXT_RUNTIME_EXTENSIONS.has(path3.extname(filePath));
+}
+function replaceBakedApiUrls(source, apiPort) {
+  let rewritten = source;
+  for (const pattern of BAKED_API_URL_PATTERNS) {
+    rewritten = rewritten.replaceAll(pattern.from, pattern.to(apiPort));
+  }
+  return rewritten;
+}
+function countApiUrlReplacements(source, apiPort) {
+  let replacements = 0;
+  for (const pattern of BAKED_API_URL_PATTERNS) {
+    if (pattern.from === pattern.to(apiPort)) {
+      continue;
+    }
+    replacements += countOccurrences(source, pattern.from);
+  }
+  return replacements;
+}
+function countOccurrences(source, needle) {
+  if (!needle) {
+    return 0;
+  }
+  let count = 0;
+  let cursor = 0;
+  while (cursor < source.length) {
+    const next = source.indexOf(needle, cursor);
+    if (next === -1) {
+      break;
+    }
+    count += 1;
+    cursor = next + needle.length;
+  }
+  return count;
+}
+function validateRewriteOutcome(stats, apiPort) {
+  if (apiPort === DEFAULT_API_PORT) {
+    return;
+  }
+  if (stats.replacements === 0) {
+    throw new Error(
+      `[t3x-local] The copied Web runtime does not contain the expected baked API URL. Refuse to start with a non-default \`--api-port\` because the browser bundle may still call http://localhost:${DEFAULT_API_PORT}. Rebuild apps/web or use the default API port.`
+    );
+  }
+}
+async function assertNoBakedApiUrlResidue(runtimeDir, apiPort) {
+  if (apiPort === DEFAULT_API_PORT) {
+    return;
+  }
+  const residue = await findBakedApiUrlResidue(runtimeDir);
+  if (residue.length === 0) {
+    return;
+  }
+  const details = residue.map(({ filePath, url }) => `- ${filePath}: ${url}`).join("\n");
+  throw new Error(
+    `[t3x-local] Refuse to start because the copied Web runtime still contains baked API URLs for port ${DEFAULT_API_PORT}.
+${details}`
+  );
+}
+async function findBakedApiUrlResidue(currentDir) {
+  const entries = await fs2.readdir(currentDir, { withFileTypes: true });
+  const residue = [];
+  for (const entry of entries) {
+    const entryPath = path3.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      residue.push(...await findBakedApiUrlResidue(entryPath));
+      continue;
+    }
+    if (!shouldRewriteRuntimeFile(entryPath)) {
+      continue;
+    }
+    const contents = await fs2.readFile(entryPath, "utf8");
+    for (const pattern of BAKED_API_URL_PATTERNS) {
+      if (contents.includes(pattern.from)) {
+        residue.push({ filePath: entryPath, url: pattern.from });
+      }
+    }
+  }
+  return residue;
+}
+
+export {
+  resolveStartOptions,
+  checkHttpHealth,
+  getPortStatus,
+  getVersionSnapshot,
+  getVersionLockReport,
+  runStartCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+interface StartCommandOptions {
+    dataDir?: string;
+    apiPort?: number;
+    webPort?: number;
+}
+declare function runStartCommand(input?: StartCommandOptions): Promise<void>;
+
+export { type StartCommandOptions, runStartCommand };

package/dist/index.js

@@ -0,0 +1,7 @@
+import {
+  runStartCommand
+} from "./chunk-KNAXB6AU.js";
+import "./chunk-E4LL4ESG.js";
+export {
+  runStartCommand
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@t3x-dev/local",
+  "version": "0.1.2",
+  "description": "T3X local entry package",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "t3x-local": "./dist/bin/t3x-local.js",
+    "t3x": "./dist/bin/t3x.js",
+    "t3x-mcp": "./dist/bin/t3x-mcp.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "scripts",
+    "runtime-manifest.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/t3x-dev/t3x-core.git",
+    "directory": "apps/local"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/bin/t3x-local.ts src/bin/t3x.ts src/bin/t3x-mcp.ts --format esm --dts --clean",
+    "dev": "tsx src/bin/t3x-local.ts",
+    "prepare:runtime": "node ./scripts/prepare-runtime.mjs",
+    "generate:runtime-manifest": "node ./scripts/generate-runtime-manifest.mjs",
+    "prepack": "node ../../tools/rewrite-workspace-package-json.mjs",
+    "postpack": "node ../../tools/restore-package-json.mjs",
+    "start": "node dist/bin/t3x-local.js start",
+    "test": "vitest run --passWithNoTests",
+    "lint": "biome lint src",
+    "postinstall": "node ./scripts/postinstall-download.mjs"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.15.2",
+    "@t3x-dev/api": "0.1.2",
+    "@t3x-dev/cli": "0.1.2",
+    "@t3x-dev/mcp": "0.1.2",
+    "@t3x-dev/storage": "0.1.2",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.9"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  }
+}

package/runtime-manifest.json

@@ -0,0 +1,38 @@
+{
+  "manifestVersion": 1,
+  "packageVersion": "0.1.2",
+  "fixedVersion": "0.1.2",
+  "generatedAt": "2026-04-23T09:12:14.667Z",
+  "dependencies": {
+    "@t3x-dev/yops": "0.1.2",
+    "@t3x-dev/yschema": "0.1.2",
+    "@t3x-dev/core": "0.1.2",
+    "@t3x-dev/storage": "0.1.2",
+    "@t3x-dev/api": "0.1.2",
+    "@t3x-dev/api-client": "0.1.2",
+    "@t3x-dev/cli": "0.1.2",
+    "@t3x-dev/mcp": "0.1.2",
+    "@t3x-dev/local": "0.1.2",
+    "web": "0.1.0"
+  },
+  "platforms": {
+    "darwin-arm64": {
+      "fileName": "t3x-local-runtime-0.1.2-darwin-arm64.tar.gz",
+      "url": "https://github.com/t3x-dev/t3x-core/releases/download/t3x-local-v0.1.2/t3x-local-runtime-0.1.2-darwin-arm64.tar.gz",
+      "sha256": "d90390ca1a90be083a78d4caf670d027985084eafbbfbc001fb84f30565b7a85",
+      "size": 20245492
+    },
+    "linux-arm64": {
+      "fileName": "t3x-local-runtime-0.1.2-linux-arm64.tar.gz",
+      "url": "https://github.com/t3x-dev/t3x-core/releases/download/t3x-local-v0.1.2/t3x-local-runtime-0.1.2-linux-arm64.tar.gz",
+      "sha256": "384afcf94e9208122a995980fbdf9fee072e14514ce269898726fd357e359b2c",
+      "size": 28136616
+    },
+    "linux-x64": {
+      "fileName": "t3x-local-runtime-0.1.2-linux-x64.tar.gz",
+      "url": "https://github.com/t3x-dev/t3x-core/releases/download/t3x-local-v0.1.2/t3x-local-runtime-0.1.2-linux-x64.tar.gz",
+      "sha256": "5ed8c8fb5597c2ecac0593ffc48f604b7484df538965c07d81663d3ad29a7c87",
+      "size": 27977895
+    }
+  }
+}