@lotics/cli 0.30.2 → 0.32.0

package/dist/src/app_commands.js

@@ -19,6 +19,32 @@ import { buildStarterTemplate } from "./starter_template.js";
 import { startDevServer, openBrowser } from "./dev/server.js";
 import { generateAppWorkflowsDts } from "./generate_app_workflows_dts.js";
 import { generateAppQueriesDts } from "./generate_app_queries_dts.js";
+/**
+ * Resolve the latest published version of a package from the npm registry.
+ * Returns null on any failure (network error, 404, malformed payload) so
+ * callers can fall back to a static pin rather than crashing `app create`.
+ *
+ * 1.5s timeout — npm registry is fast when reachable; the fallback is fine
+ * the rare times it isn't, and we don't want to block scaffold on a hang.
+ */
+async function fetchLatestNpmVersion(packageName) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1500);
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+            signal: controller.signal,
+            headers: { accept: "application/json" },
+        });
+        clearTimeout(timeout);
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        return typeof body.version === "string" ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Run `tar` and resolve when it exits cleanly. Throws with stderr on failure. */
 function runTar(args, cwd) {
     return new Promise((resolve, reject) => {
@@ -66,6 +92,10 @@ function readAppMeta(projectDir) {
         version_number: pkg.lotics.version_number ?? null,
         workflows: pkg.lotics.workflows ?? {},
         queries: pkg.lotics.queries ?? {},
+        // Left as `undefined` when absent so the deploy omits them and the
+        // App row's icon/theme is preserved.
+        icon: pkg.lotics.icon,
+        theme: pkg.lotics.theme,
     };
 }
 function writeAppMeta(projectDir, meta) {
@@ -144,11 +174,20 @@ export async function appCreate(client, args) {
     // Server-side row first — if this fails, no local files have been touched.
     const app = await client.createApp({ name: args.name });
     console.error(`Created app: ${app.name} (${app.id})`);
+    // Resolve latest versions in parallel; null falls back to the static pin
+    // baked into the starter template. Lookups time out at 1.5s so an offline
+    // create still succeeds (with the fallback) instead of hanging.
+    const [uiLatest, sdkLatest] = await Promise.all([
+        fetchLatestNpmVersion("@lotics/ui"),
+        fetchLatestNpmVersion("@lotics/app-sdk"),
+    ]);
     // Scaffold the starter into the target directory.
     const files = buildStarterTemplate({
         app_name: args.name,
         app_id: app.id,
         workspace_id: app.workspace_id,
+        ui_version: uiLatest ? `^${uiLatest}` : undefined,
+        sdk_version: sdkLatest ? `^${sdkLatest}` : undefined,
     });
     for (const file of files) {
         const fullPath = path.join(targetPath, file.path);
@@ -293,6 +332,10 @@ export async function appDeploy(client, args) {
                 // Sync apps.queries from the manifest. Server validates each query
                 // template (parseQueryNode, table access, param coverage).
                 queries: meta.queries ?? {},
+                // Optional icon/theme overrides — only sent when the manifest
+                // declares them (undefined ⇒ omitted ⇒ App row left untouched).
+                icon: meta.icon,
+                theme: meta.theme,
                 // Opt into destructive workflow removal. Default false — the server
                 // rejects deploys whose manifest is missing aliases the App row has.
                 force_workflow_sync: args.forceWorkflowSync,

package/dist/src/client.d.ts

@@ -197,6 +197,14 @@ export declare class LoticsClient {
             ast: unknown;
             params?: Record<string, unknown>;
         }>;
+        /**
+         * App icon (Lucide name) + theme `{ color }` from `package.json#lotics`.
+         * `undefined` ⇒ not sent ⇒ the deploy leaves the App row's icon/theme
+         * as-is. A present value is applied authoritatively. `icon` rides as a
+         * raw form field; `theme` is an object, so it's JSON-encoded.
+         */
+        icon?: string;
+        theme?: Record<string, unknown>;
         /**
          * Opt into destructive workflow removal. When false/absent, the server
          * rejects a deploy whose `workflows` map is missing aliases that exist

package/dist/src/client.js

@@ -216,6 +216,16 @@ export class LoticsClient {
         // Always send queries — empty object clears any previously-declared
         // named queries. Server validates each template.
         formData.append("queries", JSON.stringify(args.queries ?? {}));
+        // icon/theme are optional overrides — only sent when the manifest
+        // declares them, so a deploy never clobbers a value set in the UI.
+        // `icon` is a plain string → raw field, like `message`. `theme` is an
+        // object → JSON-encoded, like `workflows`/`queries`.
+        if (args.icon !== undefined) {
+            formData.append("icon", args.icon);
+        }
+        if (args.theme !== undefined) {
+            formData.append("theme", JSON.stringify(args.theme));
+        }
         // Only post the override flag when the user explicitly opts in. The
         // server defaults to "honor the guard" — opt-in is loud, opt-out
         // requires intent.

package/dist/src/starter_template.d.ts

@@ -29,8 +29,24 @@ export interface StarterFile {
     path: string;
     content: string;
 }
+/**
+ * Pin defaults for `@lotics/ui` and `@lotics/app-sdk` in the scaffolded
+ * package.json. Used when `lotics app create` can't resolve the latest
+ * versions from npm (no network, registry blip) — keeps `app create`
+ * working offline at the cost of a stale starter pin.
+ *
+ * Bump these in tandem with new releases of either package. Production
+ * scaffolds resolve the live version via `fetchLatestNpmVersion` and only
+ * fall back here when the lookup fails.
+ */
+export declare const STARTER_FALLBACK_UI_VERSION = "1.8.0";
+export declare const STARTER_FALLBACK_SDK_VERSION = "0.8.0";
 export declare function buildStarterTemplate(args: {
     app_name: string;
     app_id: string;
     workspace_id: string;
+    /** @lotics/ui version range, e.g. "^1.8.0". Defaults to the fallback pin. */
+    ui_version?: string;
+    /** @lotics/app-sdk version range, e.g. "^0.7.0". Defaults to the fallback pin. */
+    sdk_version?: string;
 }): StarterFile[];

package/dist/src/starter_template.js

@@ -25,7 +25,21 @@
  *   - oxlint + vitest + tsc out of the box, plus a GitHub Actions CI
  *     workflow that runs all three on every PR.
  */
+/**
+ * Pin defaults for `@lotics/ui` and `@lotics/app-sdk` in the scaffolded
+ * package.json. Used when `lotics app create` can't resolve the latest
+ * versions from npm (no network, registry blip) — keeps `app create`
+ * working offline at the cost of a stale starter pin.
+ *
+ * Bump these in tandem with new releases of either package. Production
+ * scaffolds resolve the live version via `fetchLatestNpmVersion` and only
+ * fall back here when the lookup fails.
+ */
+export const STARTER_FALLBACK_UI_VERSION = "1.8.0";
+export const STARTER_FALLBACK_SDK_VERSION = "0.8.0";
 export function buildStarterTemplate(args) {
+    const uiVersion = args.ui_version ?? `^${STARTER_FALLBACK_UI_VERSION}`;
+    const sdkVersion = args.sdk_version ?? `^${STARTER_FALLBACK_SDK_VERSION}`;
     const sanitizedPkgName = args.app_name
         .toLowerCase()
         .replace(/[^a-z0-9-]/g, "-")
@@ -50,8 +64,8 @@ export function buildStarterTemplate(args) {
                     test: "vitest run",
                 },
                 dependencies: {
-                    "@lotics/app-sdk": "^0.7.0",
-                    "@lotics/ui": "^1.3.0",
+                    "@lotics/app-sdk": sdkVersion,
+                    "@lotics/ui": uiVersion,
                     "@react-native-picker/picker": "^2.7.0",
                     "expo-image": "~3.0.9",
                     "lucide-react": "^0.562.0",
@@ -145,6 +159,15 @@ export default defineConfig({
     // Pin React (and RN-Web) to a single instance shared by every chunk.
     dedupe: ["react", "react-dom", "react-native-web"],
   },
+  optimizeDeps: {
+    // \`recharts\` (used by @lotics/ui chart_* + sparkline) imports
+    // \`es-toolkit/compat/get\` as a default-export CJS module. Vite's dev
+    // server treats \`compat/*\` as ESM and won't synthesize a default,
+    // so \`import get from "es-toolkit/compat/get"\` fails to resolve.
+    // Pre-bundling forces Vite to convert it to an ESM shim with a default
+    // export. Production build (rollup) handles it correctly without this.
+    include: ["recharts", "es-toolkit", "es-toolkit/compat"],
+  },
   build: {
     outDir: "dist",
     sourcemap: true,

package/dist/src/starter_template.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/starter_template.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "vitest";
+import { buildStarterTemplate, STARTER_FALLBACK_SDK_VERSION, STARTER_FALLBACK_UI_VERSION, } from "./starter_template.js";
+function fileNamed(files, path) {
+    const f = files.find((f) => f.path === path);
+    if (!f)
+        throw new Error(`Starter template missing file: ${path}`);
+    return f.content;
+}
+describe("buildStarterTemplate", () => {
+    const baseArgs = { app_name: "Demo", app_id: "app_test", workspace_id: "wsp_test" };
+    test("vite.config.ts pre-bundles recharts / es-toolkit for the dev server", () => {
+        const config = fileNamed(buildStarterTemplate(baseArgs), "vite.config.ts");
+        // Without this, `lotics app dev` crashes on `es-toolkit/compat/get` no
+        // default export when the app imports any @lotics/ui chart component.
+        expect(config).toMatch(/optimizeDeps:\s*\{/);
+        expect(config).toContain('"recharts"');
+        expect(config).toContain('"es-toolkit"');
+        expect(config).toContain('"es-toolkit/compat"');
+    });
+    test("package.json uses caller-supplied versions for @lotics/ui and @lotics/app-sdk", () => {
+        const pkg = JSON.parse(fileNamed(buildStarterTemplate({ ...baseArgs, ui_version: "^9.9.9", sdk_version: "^2.2.2" }), "package.json"));
+        expect(pkg.dependencies["@lotics/ui"]).toBe("^9.9.9");
+        expect(pkg.dependencies["@lotics/app-sdk"]).toBe("^2.2.2");
+    });
+    test("package.json falls back to the static pins when versions are omitted", () => {
+        // Used when `lotics app create` cannot reach the npm registry to resolve
+        // `latest`. Keeps `app create` working offline at the cost of a stale pin.
+        const pkg = JSON.parse(fileNamed(buildStarterTemplate(baseArgs), "package.json"));
+        expect(pkg.dependencies["@lotics/ui"]).toBe(`^${STARTER_FALLBACK_UI_VERSION}`);
+        expect(pkg.dependencies["@lotics/app-sdk"]).toBe(`^${STARTER_FALLBACK_SDK_VERSION}`);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/cli",
-  "version": "0.30.2",
+  "version": "0.32.0",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {