@dreamlake/dreamlake-cli 0.2.0 → 0.9.1

package/bin/dreamlake.js

@@ -1,33 +1,37 @@
 #!/usr/bin/env node
-// `dreamlake` CLI entry. Picks the compiled JS if present (production
-// install), else falls back to running the TS source through tsx
-// (workspace dev — no `pnpm build` required).
+"use strict";
+const { spawnSync } = require("node:child_process");
 
-import { existsSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import path from "node:path";
+function isMusl() {
+  if (process.platform !== "linux") return false;
+  try {
+    return !process.report.getReport().header.glibcVersionRuntime;
+  } catch {
+    return false;
+  }
+}
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const distEntry = path.join(__dirname, "..", "dist", "cli", "index.js");
-const srcEntry = path.join(__dirname, "..", "src", "cli", "index.ts");
+const key = process.platform + "-" + process.arch + (isMusl() ? "-musl" : "");
+const pkg = "@dreamlake/dreamlake-cli-" + key;
+const bin = process.platform === "win32" ? "dreamlake.exe" : "dreamlake";
 
-async function run() {
-  if (existsSync(distEntry)) {
-    await import(pathToFileURL(distEntry).href);
-    return;
-  }
-  if (existsSync(srcEntry)) {
-    // Register tsx as a module loader, then import the TS source.
-    const tsx = await import("tsx/esm/api");
-    tsx.register();
-    await import(pathToFileURL(srcEntry).href);
-    return;
-  }
-  console.error("dreamlake: neither dist/cli/index.js nor src/cli/index.ts found");
-  process.exit(2);
+let binPath;
+try {
+  binPath = require.resolve(pkg + "/" + bin);
+} catch {
+  process.stderr.write(
+    "dreamlake: no binary for " + key + ".\n" +
+    "The platform package " + pkg + " is not installed. npm skips it when\n" +
+    "os/cpu do not match, and --no-optional skips it always. Reinstall without\n" +
+    "--no-optional, or use the native installer:\n" +
+    "  curl -fsSL https://dl.dreamlake.ai/install.sh | sh\n",
+  );
+  process.exit(1);
 }
 
-run().catch((err) => {
-  console.error(err?.stack ?? err);
+const r = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+if (r.error) {
+  process.stderr.write("dreamlake: " + r.error.message + "\n");
   process.exit(1);
-});
+}
+process.exit(r.status === null ? 1 : r.status);

package/package.json

@@ -1,37 +1,29 @@
 {
   "name": "@dreamlake/dreamlake-cli",
-  "version": "0.2.0",
-  "description": "dreamlake — data-warehouse CLI. The `dreamlake` command uploads/downloads assets and manages episodes, bindrs, and datasets against a DreamLake server + BSS.",
-  "private": false,
-  "type": "module",
-  "main": "dist/cli/index.js",
+  "version": "0.9.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dreamlake-ai/dreamlake-cli.git"
+  },
+  "homepage": "https://cli.dreamlake.ai",
+  "description": "dreamlake — data-warehouse CLI. The `dreamlake` command uploads/downloads assets, manages episodes, bindrs, datasets, organizations and teams, and versions artifacts, workflow specs and pipelines against a DreamLake server + BSS.",
   "bin": {
     "dreamlake": "bin/dreamlake.js"
   },
   "files": [
-    "bin",
-    "dist",
-    "!dist/**/*.map"
+    "bin"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "tsc",
-    "cli": "tsx src/cli/index.ts",
-    "test": "tsc -p tsconfig.json --noEmit && node --import tsx --test src/cli/__tests__/*.test.ts",
-    "docs:dev": "pnpm -C docs dev",
-    "docs:build": "pnpm -C docs build",
-    "docs:preview": "pnpm -C docs preview"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.0"
+  "engines": {
+    "node": ">=18"
   },
-  "dependencies": {
-    "@inquirer/prompts": "^8.4.3",
-    "commander": "^12.1.0",
-    "yaml": "^2.6.1"
+  "optionalDependencies": {
+    "@dreamlake/dreamlake-cli-darwin-arm64": "0.9.1",
+    "@dreamlake/dreamlake-cli-darwin-x64": "0.9.1",
+    "@dreamlake/dreamlake-cli-linux-x64": "0.9.1",
+    "@dreamlake/dreamlake-cli-linux-arm64": "0.9.1",
+    "@dreamlake/dreamlake-cli-linux-x64-musl": "0.9.1",
+    "@dreamlake/dreamlake-cli-linux-arm64-musl": "0.9.1",
+    "@dreamlake/dreamlake-cli-win32-x64": "0.9.1",
+    "@dreamlake/dreamlake-cli-win32-arm64": "0.9.1"
   }
 }

package/README.md

@@ -1,171 +0,0 @@
-# dreamlake-cli
-
-`dreamlake` — a data-warehouse CLI for DreamLake. Uploads/downloads assets and
-manages episodes, bindrs, and datasets against a DreamLake server + BSS
-(big-streaming-server).
-
-It is a TypeScript port of the CLI shipped in
-[`dreamlake-py`](../dreamlake-workspace/dreamlake-py) (`dreamlake.cli`), built
-on the [`lakeshore`](../lakeshore) conventions (Commander + native `fetch`,
-pure ESM, token saved to a flat YAML file instead of the system keyring).
-
-> The compiled `dreamlake` binary shares its name with the Python `dreamlake`
-> entry point — this CLI is the TypeScript replacement. When both are on a
-> machine, `PATH` order decides which one runs.
-
-## Install / run
-
-```bash
-pnpm install
-pnpm cli --help          # dev — runs the TS source through tsx
-pnpm build               # emit dist/
-node bin/dreamlake.js …  # prod — runs compiled dist/ (falls back to tsx in dev)
-```
-
-## Auth & environments
-
-The CLI knows two built-in environments — **`staging`** and **`prod`** — so you
-never type their URLs. Each environment keeps its own token; switch between them
-with one command.
-
-```bash
-dreamlake login --env staging       # device-authorization flow (opens browser)
-dreamlake login --env prod          # built-in URLs; no --url/--bss needed
-dreamlake login                     # re-auth the active env (or staging if none)
-
-dreamlake env list                  # show logged-in envs (* = active)
-dreamlake env use prod              # switch active env — no URLs, no re-login
-dreamlake env remove staging        # forget a saved env
-
-dreamlake profile                   # current user (shows [env: ...])
-dreamlake logout                    # log out of the active env only
-```
-
-Custom / self-hosted environments — define once, then switch by name forever:
-
-```bash
-dreamlake login --env dev --url https://dev-api.example.com --bss https://dev-bss.example.com
-dreamlake env use dev
-```
-
-Flags / env vars (`DREAMLAKE_REMOTE`, `DREAMLAKE_BSS_URL`, `DREAMLAKE_API_KEY`)
-still override the active environment for one-off commands. `--token <jwt>` saves
-a token directly (skip the device flow). `--auth <url>` overrides the vuer-auth
-server (built-ins set this automatically; staging needs `staging-auth.vuer.ai`).
-
-Credentials live in `~/.config/dreamlake/auth.yml`
-(`$XDG_CONFIG_HOME/dreamlake/auth.yml`, `chmod 600`) as a multi-environment file:
-
-```yaml
-current: prod
-envs:
-  staging: { server, bss, auth, namespace, token }
-  prod:    { server, bss, auth, namespace, token }
-```
-
-## Targets
-
-Most commands take a target string:
-
-```
---episode  space[@namespace][:episode]      # e.g. robotics@alice:2026/q1/run-042
---project  space[@namespace]                 # e.g. robotics@alice
-```
-
-When `@namespace` is omitted it is resolved from your token (`/auth/me`).
-
-## Commands
-
-```bash
-# Upload — single file, or a flat directory (resumable). Type auto-detected.
-dreamlake upload ./mic.wav   --episode robotics@alice:run-042 --to /microphone/front
-dreamlake upload ./clip.mp4  --episode robotics:run-042       --to /camera/front --bindr cam-set
-dreamlake upload ./capture/  --episode robotics@alice:run-042 --to /sensors --yes
-
-# Download — a single file, or a whole folder/episode recursively.
-dreamlake download --episode robotics@alice:run-042 --from /camera/front/clip.mp4 -o ./clip.mp4
-dreamlake download --episode robotics@alice:run-042 --from /camera -o ./out/
-
-# Projects. Private by default — pass --public (or --visibility public) to share.
-dreamlake create project my-robots --description "robot captures"   # private
-dreamlake create project shared-set --public                        # public
-dreamlake update project my-robots --public                         # flip visibility later
-dreamlake list project
-dreamlake delete project my-robots            # HARD-deletes the whole subtree
-
-# List — assets (default), or projects / bindrs / datasets / episodes.
-dreamlake list --episode robotics@alice:run-042 --type video
-dreamlake list project
-dreamlake list bindr   --project robotics@alice
-dreamlake list dataset --project robotics@alice --json
-dreamlake list episode --project robotics@alice
-
-# Delete uploaded data (all HARD deletes — confirm prompt unless --yes).
-dreamlake delete file /camera/front/clip.mp4 --episode robotics@alice:run-042
-dreamlake delete episode run-042 --project robotics@alice
-
-# Bindrs (members are episodes, matched by node-path glob).
-dreamlake create bindr front-cam --project robotics@alice --episode "camera/front/*"
-dreamlake update bindr front-cam --project robotics@alice --add "2026/04/*"
-dreamlake delete bindr front-cam --project robotics@alice
-
-# Datasets (members are bindrs, matched by name glob).
-dreamlake create dataset train-v1 --project robotics@alice --tags robotics,training
-dreamlake update dataset train-v1 --project robotics@alice --add "front-*"
-dreamlake delete dataset train-v1 --project robotics@alice
-```
-
-> Videos are just files — upload/list/download them with `upload` / `list --type video`
-> / `download`, no dedicated `video` command needed.
-
-```bash
-# Organizations (GraphQL-backed; same token). Members resolve by email/name.
-dreamlake org list
-dreamlake org show my-org
-dreamlake org create my-org --name "My Org" --description "..."   # you become OWNER + a namespace is created
-dreamlake org update my-org --description "..."
-dreamlake org delete my-org                                       # must have no remaining projects
-dreamlake org leave my-org
-dreamlake org member list   my-org
-dreamlake org member add    my-org alice@example.com --role member
-dreamlake org member role   my-org alice@example.com --role owner
-dreamlake org member remove my-org alice@example.com
-
-# Teams (scoped to an org; nestable via --parent; visible|secret).
-dreamlake team list                                  # all teams you belong to
-dreamlake team list my-org                            # teams in one org
-dreamlake team show   my-org backend
-dreamlake team create my-org backend --name "Backend" --visibility secret
-dreamlake team create my-org api --parent backend    # nested team
-dreamlake team update my-org backend --visibility visible
-dreamlake team delete my-org backend                 # must have no child teams
-dreamlake team leave  my-org backend
-dreamlake team member list   my-org backend
-dreamlake team member add    my-org backend alice@example.com --role maintainer
-dreamlake team member role   my-org backend alice@example.com --role member
-dreamlake team member remove my-org backend alice@example.com
-```
-
-## Configuration
-
-Resolution precedence (high → low): flag → env var → saved `auth.yml` → default.
-
-| Setting | Env var | Default |
-| --- | --- | --- |
-| DreamLake server | `DREAMLAKE_REMOTE` | `http://localhost:10334` |
-| BSS server | `DREAMLAKE_BSS_URL` | `http://localhost:10234` |
-| Token | `DREAMLAKE_API_KEY` | (from `auth.yml`) |
-
-## Not implemented
-
-By design, the CLI excludes the parts of `dreamlake-py` that aren't
-command-line-shaped: `vectorize` (CLIP/LLaVA inference + Zaku + Qdrant), the
-SDK-only rich types (`Video`/`TextTrack`/`VectorIndex`), and the deprecated
-Episode-tracking stack.
-
-## Development
-
-```bash
-pnpm test     # tsc --noEmit + node --test (target/glob/kinds/credentials)
-pnpm build    # tsc → dist/
-```

package/dist/cli/auth/commands.js

@@ -1,240 +0,0 @@
-// `dreamlake login | logout | profile`.
-//
-// login: runs the device-authorization flow (default) or saves a token
-// passed via --token (lakeshore-style escape hatch). On success the
-// dreamlake token + resolved server/bss/namespace are written to
-// ~/.config/dreamlake/auth.yml (NOT the system keyring — see credentials.ts).
-//
-// profile: hits GET /auth/me, falling back to a local JWT decode when the
-// server is unreachable. logout: deletes the auth file.
-import { spawn } from "node:child_process";
-import { resolveRemote, resolveToken, decodeJwtPayload } from "../config.js";
-import { emitJson, renderTable } from "../helpers.js";
-import { authFilePath, builtinEnv, BUILTIN_ENVS, currentEnvName, listEnvs, removeEnv, saveEnv, useEnv, } from "./credentials.js";
-import { getOrCreateDeviceSecret } from "./device-secret.js";
-import { AuthorizationDeniedError, DeviceCodeExpiredError, DeviceFlowClient, TokenExchangeError, } from "./device-flow.js";
-async function fetchAuthMe(remote, token) {
-    try {
-        const res = await fetch(`${remote}/auth/me`, {
-            headers: { Authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(5000),
-        });
-        if (res.ok)
-            return (await res.json());
-    }
-    catch {
-        // unreachable
-    }
-    return null;
-}
-function openBrowser(url) {
-    const cmd = process.platform === "darwin"
-        ? "open"
-        : process.platform === "win32"
-            ? "start"
-            : "xdg-open";
-    try {
-        const child = spawn(cmd, [url], { stdio: "ignore", detached: true });
-        child.on("error", () => { });
-        child.unref();
-    }
-    catch {
-        // best-effort
-    }
-}
-export async function runLogin(args) {
-    // Resolve which environment we're logging into and its URLs.
-    const envName = args.env ?? currentEnvName() ?? "staging";
-    const builtin = builtinEnv(envName);
-    const remote = (args.url ?? builtin?.server)?.replace(/\/+$/, "");
-    const bss = (args.bss ?? builtin?.bss)?.replace(/\/+$/, "");
-    const auth = args.auth ?? builtin?.auth;
-    if (!remote || !bss) {
-        process.stderr.write(`✗ unknown environment '${envName}'. Either use a built-in (${Object.keys(BUILTIN_ENVS).join(", ")}) ` +
-            `or define one: dreamlake login --env ${envName} --url <api> --bss <bss>\n`);
-        return 1;
-    }
-    process.stderr.write(`Logging into environment '${envName}' (${remote})\n`);
-    // ── Escape hatch: direct token (lakeshore style) ──────────────────
-    if (args.token) {
-        const me = await fetchAuthMe(remote, args.token);
-        if (!me) {
-            process.stderr.write(`✗ token validation failed against ${remote}/auth/me\n`);
-            return 1;
-        }
-        const namespace = me.namespace?.slug ?? "";
-        const p = saveEnv(envName, { server: remote, bss, auth, namespace, token: args.token });
-        process.stdout.write(`✓ Saved env '${envName}' to ${p}\n` +
-            `  server:    ${remote}\n` +
-            `  bss:       ${bss}\n` +
-            `  namespace: ${namespace || "(none)"}\n`);
-        return 0;
-    }
-    // ── Device authorization flow ─────────────────────────────────────
-    const deviceSecret = getOrCreateDeviceSecret();
-    const client = new DeviceFlowClient(deviceSecret, remote, auth);
-    let flow;
-    try {
-        process.stderr.write("Initializing device authorization...\n\n");
-        flow = await client.startDeviceFlow();
-    }
-    catch (err) {
-        process.stderr.write(`✗ ${err.message}\n`);
-        return 1;
-    }
-    process.stdout.write(`DEVICE AUTHORIZATION REQUIRED\n\n` +
-        `  1. Visit:  ${flow.verificationUri}\n` +
-        `  2. Enter code:  ${flow.userCode}\n\n` +
-        `  (code expires in ${Math.floor(flow.expiresIn / 60)} minutes)\n\n`);
-    if (!args.noBrowser) {
-        openBrowser(flow.verificationUriComplete);
-    }
-    process.stderr.write("Waiting for authorization...\n");
-    let vuerToken;
-    try {
-        vuerToken = await client.pollForToken(120, (elapsed) => {
-            if (process.stderr.isTTY) {
-                process.stderr.write(`\r  waiting (${elapsed}s)`);
-            }
-        });
-        if (process.stderr.isTTY)
-            process.stderr.write("\n");
-    }
-    catch (err) {
-        if (process.stderr.isTTY)
-            process.stderr.write("\n");
-        if (err instanceof DeviceCodeExpiredError) {
-            process.stderr.write("✗ Device code expired. Run 'dreamlake login' again.\n");
-        }
-        else if (err instanceof AuthorizationDeniedError) {
-            process.stderr.write("✗ Authorization denied.\n");
-        }
-        else {
-            process.stderr.write(`✗ ${err.message}\n`);
-        }
-        return 1;
-    }
-    let token;
-    try {
-        process.stderr.write("Exchanging token with DreamLake server...\n");
-        token = await client.exchangeToken(vuerToken);
-    }
-    catch (err) {
-        const msg = err instanceof TokenExchangeError ? err.message : err.message;
-        process.stderr.write(`✗ ${msg}\n`);
-        return 1;
-    }
-    const me = await fetchAuthMe(remote, token);
-    const namespace = me?.namespace?.slug ?? "";
-    saveEnv(envName, { server: remote, bss, auth, namespace, token });
-    process.stdout.write(`✓ Logged in to '${envName}' (now active)\n` +
-        `  server:    ${remote}\n` +
-        `  bss:       ${bss}\n` +
-        `  namespace: ${namespace || "(none)"}\n`);
-    return 0;
-}
-// ─── logout ──────────────────────────────────────────────────────────
-export async function runLogout() {
-    const name = currentEnvName();
-    if (!name) {
-        process.stdout.write(`No active environment (${authFilePath()})\n`);
-        return 0;
-    }
-    removeEnv(name);
-    const next = currentEnvName();
-    process.stdout.write(`✓ Logged out of '${name}'.` +
-        (next ? ` Active environment is now '${next}'.\n` : " No environments left.\n"));
-    return 0;
-}
-// ─── env (environment switching) ──────────────────────────────────────
-export async function runEnvList(opts) {
-    const envs = listEnvs();
-    if (opts.json) {
-        emitJson(envs.map((e) => ({
-            name: e.name,
-            current: e.current,
-            server: e.env.server,
-            bss: e.env.bss,
-            namespace: e.env.namespace,
-        })));
-        return 0;
-    }
-    process.stdout.write("Environments\n\n");
-    if (envs.length === 0) {
-        process.stdout.write(`  (none logged in)\n  hint: dreamlake login --env staging   (built-in: ${Object.keys(BUILTIN_ENVS).join(", ")})\n`);
-        return 0;
-    }
-    const rows = envs.map((e) => ({
-        "": e.current ? "*" : "",
-        name: e.name,
-        server: e.env.server,
-        namespace: e.env.namespace || "(none)",
-    }));
-    process.stdout.write(renderTable(rows, ["", "name", "server", "namespace"]));
-    return 0;
-}
-export async function runEnvUse(name) {
-    if (useEnv(name)) {
-        process.stdout.write(`✓ Active environment is now '${name}'\n`);
-        return 0;
-    }
-    const known = listEnvs().map((e) => e.name);
-    process.stderr.write(`✗ environment '${name}' is not logged in.\n` +
-        (known.length ? `  logged in: ${known.join(", ")}\n` : "") +
-        `  log in with: dreamlake login --env ${name}\n`);
-    return 1;
-}
-export async function runEnvRemove(name) {
-    if (removeEnv(name)) {
-        process.stdout.write(`✓ Removed environment '${name}'\n`);
-        return 0;
-    }
-    process.stderr.write(`✗ environment '${name}' not found\n`);
-    return 1;
-}
-export async function runProfile(args) {
-    const token = resolveToken();
-    if (!token) {
-        process.stdout.write("Not logged in. Run: dreamlake login\n");
-        return 1;
-    }
-    const remote = resolveRemote(args.url);
-    const me = await fetchAuthMe(remote, token);
-    if (me) {
-        const envName = currentEnvName();
-        process.stdout.write(`Current DreamLake user${envName ? `  [env: ${envName}]` : ""}\n`);
-        for (const field of ["id", "sub", "username", "name", "email"]) {
-            if (me[field] != null)
-                process.stdout.write(`  ${field}: ${me[field]}\n`);
-        }
-        if (me.namespace?.slug) {
-            process.stdout.write(`  namespace: ${me.namespace.slug}  (id: ${me.namespace.id ?? "?"})\n`);
-        }
-        if (me.createdAt) {
-            process.stdout.write(`  member since: ${String(me.createdAt).slice(0, 10)}\n`);
-        }
-        return 0;
-    }
-    // Fallback: decode JWT locally.
-    process.stderr.write("⚠ could not reach server, showing local token info.\n");
-    const payload = decodeJwtPayload(token);
-    if (Object.keys(payload).length === 0) {
-        process.stdout.write("Failed to decode token. Please log in again.\n");
-        return 1;
-    }
-    process.stdout.write("Current DreamLake user (from token)\n");
-    for (const field of ["sub", "username", "name", "email"]) {
-        if (payload[field] != null) {
-            process.stdout.write(`  ${field}: ${payload[field]}\n`);
-        }
-    }
-    const exp = payload.exp;
-    if (typeof exp === "number") {
-        const expired = exp < Date.now() / 1000;
-        process.stdout.write(`  expires: ${new Date(exp * 1000).toISOString()}${expired ? " (EXPIRED)" : ""}\n`);
-    }
-    else {
-        process.stdout.write("  expires: never (long-lived token)\n");
-    }
-    return 0;
-}

package/dist/cli/auth/constants.js

@@ -1,16 +0,0 @@
-// Authentication constants — port of dreamlake-py's auth/constants.py.
-/**
- * Vuer-auth server URL (device-flow provider). Resolved lazily so a
- * `--auth` flag / late env assignment can override it. NOTE: this must
- * match the auth server the TARGET dreamlake-server trusts — e.g.
- * staging-api.dreamlake.ai validates tokens from staging-auth.vuer.ai,
- * not the production auth.vuer.ai (mismatched keys → "No matching key
- * found in JWKS").
- */
-export function vuerAuthUrl(override) {
-    return (override || process.env.VUER_AUTH_URL || "https://auth.vuer.ai").replace(/\/+$/, "");
-}
-/** OAuth client ID for dreamlake. */
-export const CLIENT_ID = "dreamlake-client";
-/** Default OAuth scopes. */
-export const DEFAULT_SCOPE = "openid profile email";