uplink-cli 0.1.39 → 0.2.1

package/cli/src/tui/snapshot.ts

@@ -5,10 +5,14 @@ import { getResolvedApiBase, getResolvedApiToken } from "../utils/api-base";
 import type { MenuStatus } from "./App";
 
 const SNAPSHOT_TIMEOUT_MS = 2000;
+/** Hard max for a single upload (paid). Free accounts are tighter via /v1/me. */
 const ARTIFACT_CAP_BYTES = 500_000_000;
 
 export { ARTIFACT_CAP_BYTES };
 
+const FREE_STORAGE = 100_000_000;
+const FREE_APP_LIMIT = 1;
+
 type JsonObject = Record<string, unknown>;
 
 function localTunnels(): MenuStatus["tunnels"] {
@@ -76,19 +80,44 @@ async function fetchHealth(): Promise<{ connected: boolean; latencyMs: number |
   return { connected: true, latencyMs: Date.now() - started };
 }
 
+function parseHosting(me: JsonObject | null): {
+  storageUsedBytes: number;
+  storageLimitBytes: number;
+  appLimit: number;
+  alwaysOn: boolean;
+  idleMinutes: number | null;
+} {
+  const hosting = asObject(me?.hosting);
+  const storage = asObject(hosting?.storageBytes);
+  const apps = asObject(hosting?.apps);
+  const used = Number(storage?.used);
+  const limit = Number(storage?.limit);
+  const appLimit = Number(apps?.limit);
+  return {
+    storageUsedBytes: Number.isFinite(used) ? used : 0,
+    storageLimitBytes: Number.isFinite(limit) ? limit : FREE_STORAGE,
+    appLimit: Number.isFinite(appLimit) ? appLimit : FREE_APP_LIMIT,
+    alwaysOn: hosting?.alwaysOn === true,
+    idleMinutes: typeof hosting?.idleMinutes === "number" ? hosting.idleMinutes : 30,
+  };
+}
+
 export async function fetchMenuSnapshot(): Promise<MenuStatus> {
   const tunnels = localTunnels();
-  const [healthStatus, apps, providers] = await Promise.all([
+  const [healthStatus, apps, providers, meBody] = await Promise.all([
     fetchHealth(),
     fetchApps(),
     Promise.resolve(connectedProviders()),
+    apiGet("/v1/me"),
   ]);
+  const hosting = parseHosting(asObject(meBody));
   return {
     connected: healthStatus.connected,
     latencyMs: healthStatus.latencyMs,
     tunnels,
     apps,
     providers,
+    ...hosting,
   };
 }
 

package/cli/src/utils/api-base.ts

@@ -2,6 +2,7 @@ import { homedir } from "os";
 import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { createInterface } from "readline";
+import { readStoredCredentials } from "./credentials";
 
 export const DEFAULT_API_BASE = "https://api.uplink.spot";
 
@@ -75,6 +76,8 @@ export function getResolvedApiBase(): string {
   if (envBase) return envBase;
   const parsedToken = parseTokenEnv(process.env.AGENTCLOUD_TOKEN);
   if (parsedToken.apiBase) return parsedToken.apiBase;
+  const storedBase = normalizeApiBase(readStoredCredentials()?.apiBase);
+  if (storedBase) return storedBase;
   const configBase = readApiBaseConfig();
   if (configBase) return configBase;
   return DEFAULT_API_BASE;
@@ -83,6 +86,8 @@ export function getResolvedApiBase(): string {
 export function getResolvedApiToken(apiBase: string): string | undefined {
   const parsedToken = parseTokenEnv(process.env.AGENTCLOUD_TOKEN);
   if (parsedToken.token) return parsedToken.token;
+  const stored = readStoredCredentials();
+  if (stored?.token) return stored.token;
   if (isLocalApiBase(apiBase)) {
     return process.env.AGENTCLOUD_TOKEN_DEV || undefined;
   }
@@ -128,6 +133,12 @@ export async function ensureApiBase(options: { interactive: boolean }): Promise<
     return parsedToken.apiBase;
   }
 
+  const storedBase = normalizeApiBase(readStoredCredentials()?.apiBase);
+  if (storedBase) {
+    process.env.AGENTCLOUD_API_BASE = storedBase;
+    return storedBase;
+  }
+
   const configBase = readApiBaseConfig();
   if (configBase) {
     process.env.AGENTCLOUD_API_BASE = configBase;

package/cli/src/utils/credentials.ts

@@ -0,0 +1,58 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export type StoredCredentials = {
+  token: string;
+  userId?: string;
+  email?: string;
+  accountType?: "guest" | "verified";
+  apiBase?: string;
+  updatedAt?: string;
+};
+
+function credentialsDir(): string {
+  return join(homedir(), ".uplink");
+}
+
+export function credentialsPath(): string {
+  return join(credentialsDir(), "credentials");
+}
+
+export function readStoredCredentials(): StoredCredentials | null {
+  try {
+    const path = credentialsPath();
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as StoredCredentials;
+    if (!parsed?.token || typeof parsed.token !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export function writeStoredCredentials(creds: StoredCredentials): string {
+  const dir = credentialsDir();
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    chmodSync(dir, 0o700);
+  } catch {
+    /* best effort */
+  }
+  const path = credentialsPath();
+  const body: StoredCredentials = {
+    token: creds.token,
+    userId: creds.userId,
+    email: creds.email,
+    accountType: creds.accountType,
+    apiBase: creds.apiBase,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(path, JSON.stringify(body, null, 2) + "\n", { mode: 0o600 });
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    /* best effort */
+  }
+  return path;
+}

package/cli/src/utils/domain-availability.ts

@@ -0,0 +1,56 @@
+import { promises as dns } from "dns";
+import fetch from "node-fetch";
+
+export type PublicAvailability = {
+  domain: string;
+  status: "available" | "taken" | "unknown";
+  source: "dns" | "rdap";
+  detail: string;
+};
+
+const RDAP_TIMEOUT_MS = 8000;
+
+/**
+ * Registrar-free availability check: DNS nameservers first (fast, definitive
+ * for registered domains), then RDAP for the authoritative registration record.
+ * Price and purchase still require a connected registrar.
+ */
+export async function checkDomainAvailability(domain: string): Promise<PublicAvailability> {
+  try {
+    const nameservers = await dns.resolveNs(domain);
+    if (nameservers.length > 0) {
+      return { domain, status: "taken", source: "dns", detail: "domain has nameservers" };
+    }
+  } catch {
+    // NXDOMAIN or no NS records — RDAP decides.
+  }
+
+  let lastFailure = "RDAP unreachable";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const response = await fetch(`https://rdap.org/domain/${encodeURIComponent(domain)}`, {
+        headers: { accept: "application/rdap+json" },
+        timeout: RDAP_TIMEOUT_MS,
+      });
+      if (response.status === 404) {
+        return { domain, status: "available", source: "rdap", detail: "no registration record" };
+      }
+      if (response.ok) {
+        return { domain, status: "taken", source: "rdap", detail: "registration record exists" };
+      }
+      lastFailure = `RDAP returned ${response.status}`;
+    } catch (error) {
+      lastFailure = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { domain, status: "unknown", source: "rdap", detail: lastFailure };
+}
+
+export function formatPublicAvailability(result: PublicAvailability): string {
+  const lines = [`${result.domain}  ${result.status}  (${result.detail})`];
+  if (result.status === "available") {
+    lines.push("  Availability is from public DNS/RDAP. For price and purchase, connect a registrar:");
+    lines.push("  uplink domains providers connect godaddy --token-env GODADDY_PAT");
+  }
+  return lines.join("\n");
+}

package/cli/src/utils/guest-access.ts

@@ -0,0 +1,38 @@
+import fetch from "node-fetch";
+import { getResolvedApiBase, getResolvedApiToken } from "./api-base";
+import { readStoredCredentials, writeStoredCredentials } from "./credentials";
+
+type GuestSignup = {
+  token: string;
+  userId: string;
+  accountType?: "guest";
+};
+
+export async function ensureGuestAccess(options: { force?: boolean } = {}): Promise<void> {
+  const apiBase = getResolvedApiBase();
+  // force: mint a fresh guest token even when one resolves (e.g. it was rejected by the API).
+  if (!options.force && getResolvedApiToken(apiBase)) return;
+
+  const response = await fetch(`${apiBase}/v1/signup`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ label: "Automatic guest access" }),
+  });
+  const json = (await response.json().catch(() => ({}))) as GuestSignup & {
+    error?: { code?: string; message?: string };
+  };
+  if (!response.ok || !json.token) {
+    const code = json.error?.code || "GUEST_ACCESS_FAILED";
+    const message = json.error?.message || response.statusText;
+    throw new Error(`${code}: ${message}`);
+  }
+
+  writeStoredCredentials({
+    ...(readStoredCredentials() ?? {}),
+    token: json.token,
+    userId: json.userId,
+    accountType: "guest",
+    apiBase,
+  });
+  process.env.AGENTCLOUD_TOKEN = json.token;
+}

package/cli/src/utils/login-flow.ts

@@ -0,0 +1,57 @@
+import { unauthenticatedRequest } from "../subcommands/menu/requests";
+import { getResolvedApiBase } from "./api-base";
+import { writeStoredCredentials } from "./credentials";
+
+export type LoginToken = {
+  id: string;
+  token: string;
+  tokenPrefix: string;
+  role: string;
+  userId: string;
+  label: string;
+  createdAt: string;
+  expiresAt: string | null;
+  message?: string;
+};
+
+export function normalizeEmail(raw: string): string {
+  return raw.trim().toLowerCase();
+}
+
+export function isEmail(raw: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalizeEmail(raw));
+}
+
+export async function requestLoginCode(email: string): Promise<{ ok: boolean; message?: string }> {
+  return unauthenticatedRequest(
+    "POST",
+    "/v1/auth/otp/request",
+    { email: normalizeEmail(email) },
+    { includeCurrentToken: true }
+  );
+}
+
+export async function verifyLoginCode(email: string, code: string): Promise<LoginToken> {
+  return unauthenticatedRequest(
+    "POST",
+    "/v1/auth/otp/verify",
+    {
+      email: normalizeEmail(email),
+      code: code.trim(),
+    },
+    { includeCurrentToken: true }
+  );
+}
+
+export function persistLogin(result: { token: string; userId: string }, email?: string): string {
+  const apiBase = getResolvedApiBase();
+  const path = writeStoredCredentials({
+    token: result.token,
+    userId: result.userId,
+    email,
+    accountType: email ? "verified" : "guest",
+    apiBase,
+  });
+  process.env.AGENTCLOUD_TOKEN = result.token;
+  return path;
+}

package/docs/AGENTS.md

@@ -7,13 +7,15 @@ Package name: `uplink-cli` · Binary: `uplink`
 
 ## Auth
 
+- `uplink tunnel create` automatically creates guest access when no token exists. Guest access includes **1 active tunnel**, expiring after **24 hours**.
 - Use `AGENTCLOUD_TOKEN` (bearer). Prefer stdin over argv:
   ```bash
   echo "$TOKEN" | uplink --token-stdin …
   ```
+- Humans: `uplink login --email you@example.com` then `--code 123456`. This upgrades current guest access, preserves its tunnel, and unlocks persistent features. Credentials are saved to `~/.uplink/credentials` (chmod 600).
 - API base: `--api-base https://api.uplink.spot` or `AGENTCLOUD_API_BASE`.
 
-## Signup (no auth required)
+## Explicit guest token (optional)
 
 ```bash
 uplink signup --json
@@ -26,6 +28,8 @@ Save `token` from the JSON — it is shown only once. Then:
 export AGENTCLOUD_TOKEN='…'
 ```
 
+Explicit signup creates guest access. A later email login upgrades that guest account when the current token is available.
+
 ## Machine-mode contract
 
 | Rule | Detail |
@@ -37,8 +41,12 @@ export AGENTCLOUD_TOKEN='…'
 | Exit `20` | network |
 | Exit `30` | server / unknown |
 
+Guest accounts can share one local port and use public domain search. Hosting, databases, aliases, and custom domains require a verified email account. Gate error: `ACCOUNT_VERIFICATION_REQUIRED`.
+
 Premium aliases may return `ALIAS_NOT_ENABLED` / `ALIAS_LIMIT_REACHED`.
 
+Free hosting (new accounts): **1 app**, **100 MB** of live artifacts, **no custom domains**, app **sleeps after 30 minutes idle**. Errors: `HOST_APP_LIMIT_REACHED`, `HOST_STORAGE_LIMIT_REACHED`, `HOST_DOMAIN_NOT_ENABLED`. Check quota: the `hosting` object on `GET /v1/me`.
+
 ## Tunnels (share localhost)
 
 `tunnel create` **creates the API record and starts the local client** so the public URL works. Use `--api-only` only if you will start the client yourself.
@@ -110,6 +118,7 @@ The bare `uplink domains` search TUI is **optional** and not bundled with npm
 uplink domains providers connect godaddy --token-env GODADDY_PAT --json
 uplink domains providers connect cloudflare --token-env CF_API_TOKEN --json
 uplink domains providers connect hostinger --token-env HOSTINGER_API_TOKEN --json
+uplink domains providers connect dreamhost --token-env DREAMHOST_API_KEY --json
 uplink domains providers connect namecheap --token-env NAMECHEAP_API_KEY --user-env NAMECHEAP_API_USER --json
 uplink domains providers list --json
 uplink domains providers disconnect godaddy --json
@@ -123,7 +132,7 @@ echo "$TOKEN" | uplink --token-stdin host domains list --id app_xxx --json
 echo "$TOKEN" | uplink --token-stdin host domains remove --id app_xxx --hostname example.com --json
 ```
 
-Do not treat RDAP “available” as buyable unless `domains check` says `buyable: true`. Purchase is not wired yet.
+`domains check` works without a registrar: it falls back to public DNS/RDAP and returns `provider: "public"` with no price. Do not treat RDAP “available” as buyable unless `domains check` says `buyable: true`. Purchase is not wired yet.
 
 ## Databases (optional)
 
@@ -142,6 +151,10 @@ echo "$TOKEN" | uplink --token-stdin db delete --id db_xxx --yes --json
 | Auth errors | Missing/invalid `AGENTCLOUD_TOKEN`; use `--token-stdin` |
 | `ALIAS_NOT_ENABLED` | Account does not have permanent aliases |
 | Domain search TUI missing | Expected on npm — use `domains list` / `check` / `host domains *` |
+| `HOST_APP_LIMIT_REACHED` | Free plan is 1 hosted app — delete one or the account needs hosting granted |
+| `HOST_STORAGE_LIMIT_REACHED` | Upload exceeds the 100 MB free hosting budget |
+| `HOST_DOMAIN_NOT_ENABLED` | Custom domains are paid — `*.host.uplink.spot` still works |
+| First request after idle is slow | Free apps sleep after 30 minutes; the router wakes them |
 | Hosting stuck `queued` | Edge builder/runner issue — check `host status` / `host logs` |
 
 ## Interactive menu
@@ -157,5 +170,7 @@ Agents should prefer the non-interactive commands above.
 ## More
 
 - Menu map: `docs/MENU_STRUCTURE.md`
+- Hosting: `docs/HOSTING.md`
+- Product: `docs/PRODUCT.md`
 - Website: https://uplink.spot
 - npm: https://www.npmjs.com/package/uplink-cli

package/docs/HOSTING.md

@@ -0,0 +1,55 @@
+# Hosting
+
+Verified accounts can deploy apps to `*.host.uplink.spot`. Guests cannot — the API returns `ACCOUNT_VERIFICATION_REQUIRED`.
+
+## Commands
+
+```bash
+echo "$TOKEN" | uplink --token-stdin host setup --path . --name myapp --yes --json
+echo "$TOKEN" | uplink --token-stdin host deploy --path . --name myapp --wait --json
+echo "$TOKEN" | uplink --token-stdin host list --json
+echo "$TOKEN" | uplink --token-stdin host status --id app_xxx --json
+echo "$TOKEN" | uplink --token-stdin host logs --id app_xxx --json
+echo "$TOKEN" | uplink --token-stdin host delete --id app_xxx --yes --json
+```
+
+Public URL is `https://<app_id>.host.uplink.spot` (the app **id**, not the name). Custom hostnames attach with `host domains add` / `verify`.
+
+## What gets deployed
+
+- Next.js (App Router): `output: "standalone"` in `next.config`.
+- Vite / CRA: static `dist` or `build`.
+- Anything else: a `Dockerfile` in the project root.
+
+Use a `.uplinkignore` so `node_modules`, `.next`, `dist`, logs, and local databases are not uploaded.
+
+## Free-plan quotas
+
+From `GET /v1/me` → `hosting`:
+
+| Limit | Typical free account |
+|-------|----------------------|
+| Apps | 1 |
+| Live artifacts | 100 MB |
+| Custom domains | off (`HOST_DOMAIN_NOT_ENABLED`) |
+| Idle sleep | 30 minutes with no traffic |
+
+The platform URL still works when custom domains are gated.
+
+## Sleep and wake
+
+After idle timeout the runner stops the container and keeps the image. Status is `sleeping`, not deleted.
+
+The next HTTPS request to the app URL (or a verified custom domain) tells the router to wake it. Expect ~1–4 seconds on first hit, then normal latency.
+
+`host list` still shows sleeping apps. `host status` is where you see `running` vs `sleeping`.
+
+## Errors
+
+| Code | Meaning |
+|------|---------|
+| `ACCOUNT_VERIFICATION_REQUIRED` | Guest token — run `uplink login` |
+| `HOST_APP_LIMIT_REACHED` | Delete an app or raise the plan |
+| `HOST_STORAGE_LIMIT_REACHED` | Artifact too large |
+| `HOST_DOMAIN_NOT_ENABLED` | Custom domain not on this plan |
+| `NOT_READY` | Logs/status before a deployment is running |

package/docs/MENU_STRUCTURE.md

@@ -13,20 +13,24 @@ The menu adapts by auth and role. Arrow keys + Enter (no numeric entry).
 
 | State | Condition | Main options |
 |-------|-----------|--------------|
-| Unauthenticated | No / invalid `AGENTCLOUD_TOKEN` | Get Started, Find a domain, About, Exit |
-| User | Valid token | Share, Hosting, Domains, About, Exit |
+| Guest | No / invalid token → guest access is created silently on menu open | Share, Check domain availability, Continue with email, About, Exit |
+| Verified user | Email-verified token | Share, Hosting, Domains, About, Exit |
 | Admin | `role: admin` | Same as user + Usage, System Status, Manage Tokens |
+| Offline | API unreachable | Connection details, About, Exit |
+
+There is no separate "unauthenticated" menu: opening the menu without a usable token mints a guest token (1 active tunnel, 24-hour expiry) and shows the same Share menu everyone gets — including port scanning and tunnel management.
 
 ---
 
-## Unauthenticated
+## Guest
 
 ```
 UPLINK
-● offline
+● connected
 
-Get Started          → signup; optional save AGENTCLOUD_TOKEN to shell rc
-Find a domain        → domain search TUI if Domainking is available
+Share                     → same full Share menu as verified users (no Aliases)
+Check domain availability → Domainking TUI if bundled, else inline `domains check` (public DNS/RDAP)
+Continue with email       → preserve guest tunnel; unlock Hosting + Domains
 About
 Exit
 ```

package/docs/PRODUCT.md

@@ -0,0 +1,64 @@
+# Uplink
+
+**Software for agents** — share localhost, host apps, and attach domains from the terminal. No dashboard required.
+
+Website: [uplink.spot](https://uplink.spot) · CLI: [`uplink-cli`](https://www.npmjs.com/package/uplink-cli) · Agents: [AGENTS.md](../AGENTS.md)
+
+## What it is
+
+Three surfaces, one CLI (`uplink`):
+
+1. **Share** — expose `localhost:<port>` as HTTPS (`https://<token>.x.uplink.spot`).
+2. **Hosting** — deploy a project to `https://<app_id>.host.uplink.spot` (email-verified accounts).
+3. **Domains** — check availability, list registrar inventory, attach a hostname to a hosted app.
+
+Humans use `uplink` (keyboard menu). Agents use subcommands with `--json` and `--token-stdin`.
+
+## Accounts
+
+| Kind | How you get it | Can do | Cannot do |
+|------|----------------|--------|-----------|
+| **Guest** | Automatic on `tunnel create` or menu open | 1 tunnel (24h), public `domains check` | Hosting, databases, aliases, custom domains |
+| **Verified** | `uplink login --email` then OTP | Guest plus hosting / DBs / registrars | Plan-gated extras (aliases, custom domains) |
+| **Admin** | Operator token in the control plane | Everything + Usage / System Status / Manage Tokens | — |
+
+Guest → verified **merges**: the existing tunnel stays; credentials land in `~/.uplink/credentials` (mode 600). Gate error for locked features: `ACCOUNT_VERIFICATION_REQUIRED`.
+
+## URLs
+
+| Kind | Format |
+|------|--------|
+| Tunnel | `https://<token>.x.uplink.spot` |
+| Alias (plan) | `https://<alias>.uplink.spot` |
+| Hosted app | `https://<app_id>.host.uplink.spot` |
+| Custom domain | hostname attached + verified on an app |
+
+Reserved alias labels include `www`, `api`, `x`, `host`, `docs`, `status`.
+
+## Architecture (high level)
+
+```
+localhost  --tunnel client-->  relay (*.x.uplink.spot)
+                               control plane API (api.uplink.spot)
+hosted app --container------>  runner + router (*.host.uplink.spot)
+Caddy terminates TLS (Cloudflare DNS-01 wildcards).
+```
+
+The CLI repo is public. The control plane, builder, runner, router, and relay live in a private runtime repo.
+
+## Hosting behavior
+
+Free apps **sleep after 30 minutes idle**. A request wakes them (first hit is slower). See [HOSTING.md](./HOSTING.md).
+
+## vs a typical tunnel SaaS
+
+| | Uplink | Typical tunnel dashboard |
+|--|--------|--------------------------|
+| Signup to share localhost | Guest token, no email | Account + browser |
+| Agent install | `npx uplink-cli` + `--json` | Scraping a UI |
+| Hosting | Same CLI | Separate product |
+| Custom domains | Attach to a hosted app | Often a paid add-on |
+
+## License
+
+CLI: MIT. Runtime: private.

package/docs/README.md

@@ -11,11 +11,14 @@ uplink --help        # commands
 ## Documentation
 
 - **[AGENTS.md](../AGENTS.md)** (also mirrored here) — programmatic CLI for AI agents
+- **[PRODUCT.md](./PRODUCT.md)** — what Uplink is, account types, URLs
+- **[HOSTING.md](./HOSTING.md)** — deploy, quotas, sleep/wake
 - **[MENU_STRUCTURE.md](./MENU_STRUCTURE.md)** — interactive menu reference
-- **[OPEN_SOURCE_CLI.md](./OPEN_SOURCE_CLI.md)** — public CLI vs private backend scope
+- **[CHANGELOG.md](../CHANGELOG.md)** — releases
 
 ## Links
 
 - Website: [uplink.spot](https://uplink.spot)
 - npm: [uplink-cli](https://www.npmjs.com/package/uplink-cli)
+- Source: [github.com/firstprinciplecode/uplink](https://github.com/firstprinciplecode/uplink)
 - API: `https://api.uplink.spot`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uplink-cli",
-  "version": "0.1.39",
+  "version": "0.2.1",
   "description": "Software for agents — share localhost, host apps, and attach domains from the terminal. JSON-first CLI for Cursor, Claude, Codex, and Windsurf.",
   "keywords": [
     "ai-agents",
@@ -42,7 +42,11 @@
     "AGENTS.md",
     "docs/README.md",
     "docs/AGENTS.md",
-    "docs/MENU_STRUCTURE.md"
+    "docs/MENU_STRUCTURE.md",
+    "docs/HOSTING.md",
+    "docs/PRODUCT.md",
+    "CHANGELOG.md",
+    "tsconfig.json"
   ],
   "scripts": {
     "dev:cli": "tsx cli/src/index.ts",

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "types": ["node", "react"],
+    "typeRoots": ["./node_modules/@types"]
+  },
+  "include": [
+    "cli/src/**/*",
+    "scripts/**/*"
+  ]
+}