@lotics/cli 0.68.0 → 0.70.0

package/README.md

@@ -87,6 +87,7 @@ Workspaces live inside the active org. If the org has more than one, select befo
 lotics workspace                    # list workspaces in the active org (marks current)
 lotics workspace select wks_...     # set the workspace for the active scope (pin or profile)
 lotics workspace create "Sales"     # create a new workspace (admin only)
+lotics workspace delete wks_... --yes  # delete a workspace (admin only; soft delete, recoverable)
 ```
 
 Single-workspace organizations auto-select on first use. The selection is remembered per org, so switching back lands where you left off.

package/dist/args.d.ts

@@ -30,6 +30,8 @@ export declare function parseArgs(argv: string[]): {
         message?: string;
         local: boolean;
         all: boolean;
+        /** `--yes` (alias `-y`): confirm a destructive command (e.g. `workspace delete`) non-interactively. */
+        yes: boolean;
         /** `--print-created` (alias `--report-effects`): print the honest post-run side-effect harvest. */
         printCreated: boolean;
         /** `--cleanup`: also delete the harvested created records (records only). */

package/dist/args.js

@@ -25,6 +25,7 @@ export function parseArgs(argv) {
         message: undefined,
         local: false,
         all: false,
+        yes: false,
         printCreated: false,
         cleanup: false,
         version: false,
@@ -80,6 +81,10 @@ export function parseArgs(argv) {
             case "--all":
                 flags.all = true;
                 break;
+            case "--yes":
+            case "-y":
+                flags.yes = true;
+                break;
             case "--print-created":
             case "--report-effects":
                 flags.printCreated = true;

package/dist/args.test.js

@@ -63,6 +63,14 @@ describe("parseArgs", () => {
         expect(parseArgs(["app", "workflow", "run", "wf"]).flags.cleanup).toBe(false);
         expect(parseArgs(["app", "workflow", "run", "wf"]).flags.printCreated).toBe(false);
     });
+    it("parses --yes and -y as the same boolean confirmation flag (default false)", () => {
+        expect(parseArgs(["workspace", "delete", "wsp_1", "--yes"]).flags.yes).toBe(true);
+        expect(parseArgs(["workspace", "delete", "wsp_1", "-y"]).flags.yes).toBe(true);
+        const r = parseArgs(["workspace", "delete", "wsp_1"]);
+        expect(r.flags.yes).toBe(false);
+        // The boolean flag does not consume the id positional.
+        expect(parseArgs(["workspace", "delete", "wsp_1", "--yes"]).toolArgs).toBe("wsp_1");
+    });
     it("treats `org use <name>` as command / subcommand / positional", () => {
         const r = parseArgs(["org", "use", "Acme Corp"]);
         expect(r.command).toBe("org");

package/dist/cli.js

@@ -60,6 +60,7 @@ COMMANDS
   lotics workspace                     List workspaces in the active org (marks current)
   lotics workspace select <id>         Switch to a different workspace
   lotics workspace create <name>       Create a new workspace (admin only)
+  lotics workspace delete <id> --yes   Delete a workspace (admin only; soft delete, recoverable)
   lotics tools                         List all available tools
   lotics tools <name>                  Show tool description and input schema
   lotics run <tool> '<json>'           Execute a tool
@@ -688,10 +689,41 @@ async function main() {
             }
             return;
         }
+        if (subcommand === "delete") {
+            const targetId = toolArgs;
+            if (!targetId) {
+                console.error('Usage: lotics workspace delete <workspace_id> --yes');
+                process.exit(1);
+            }
+            const target = workspaces.find((ws) => ws.id === targetId);
+            if (!target) {
+                console.error(`Workspace not found: ${targetId}\n\nAvailable workspaces:`);
+                printWorkspaceList(workspaces, currentWorkspaceId);
+                process.exit(1);
+            }
+            // Destructive + irreversible-looking to the user — require an explicit
+            // confirmation (this CLI is used non-interactively by agents and scripts).
+            if (!flags.yes) {
+                console.error(`This deletes workspace "${target.name}" (${target.id}) — every table, app, record, and template inside it becomes inaccessible (soft delete: retained and recoverable by an admin).`);
+                console.error(`Re-run with --yes to confirm:  lotics workspace delete ${target.id} --yes`);
+                process.exit(1);
+            }
+            const deleted = await client.deleteWorkspace(target.id);
+            if (flags.json) {
+                console.log(JSON.stringify(deleted, null, 2));
+            }
+            else {
+                console.error(`Deleted workspace: ${target.name} (${target.id})`);
+                if (currentWorkspaceId === target.id) {
+                    console.error('This was your selected workspace — select another with "lotics workspace select <id>".');
+                }
+            }
+            return;
+        }
         // Default: list workspaces
         if (subcommand && subcommand !== "list") {
             console.error(`Unknown workspace subcommand: ${subcommand}`);
-            console.error('Usage: lotics workspace [list | select <id> | create <name>]');
+            console.error('Usage: lotics workspace [list | select <id> | create <name> | delete <id> --yes]');
             process.exit(1);
         }
         if (flags.json) {

package/dist/client.d.ts

@@ -93,6 +93,10 @@ export declare class LoticsClient {
         name: string;
         timezone?: string;
     }): Promise<WorkspaceInfo>;
+    deleteWorkspace(id: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
     login(): Promise<{
         email: string;
     }>;

package/dist/client.js

@@ -142,6 +142,9 @@ export class LoticsClient {
     async createWorkspace(body) {
         return this.request("POST", "/v1/workspaces", body);
     }
+    async deleteWorkspace(id) {
+        return this.request("DELETE", `/v1/workspaces/${encodeURIComponent(id)}`);
+    }
     async login() {
         return this.request("POST", "/v1/cli/login");
     }

package/dist/generate_app_workflows_dts.d.ts

@@ -26,7 +26,9 @@ export declare function generateAppWorkflowsDts(workflows: Record<string, AppWor
  * to `unknown` rather than throwing — the server's deploy-time schema parse
  * catches structurally-invalid declarations before they reach us.
  */
-export declare function inputsToType(inputs: Record<string, unknown>): string;
+export declare function inputsToType(inputs: Record<string, unknown>, opts?: {
+    nullableOptional?: boolean;
+}): string;
 /**
  * Map an output `fields` map (also the top-level `outputs`) to a TS object type.
  * Mirrors the backend `outputObjectToTsType`; recursive for nested object/array.

package/dist/generate_app_workflows_dts.js

@@ -41,7 +41,7 @@ declare module "@lotics/app-sdk" {
         // No typed inputs ⇒ untyped `Record<string, unknown>` callable. An alias with
         // declared `outputs` also gets an `AppWorkflowResults` entry → typed result.data.
         const valueType = declaration.inputs
-            ? inputsToType(declaration.inputs)
+            ? inputsToType(declaration.inputs, { nullableOptional: true })
             : "Record<string, unknown>";
         const aliasKey = isValidIdentifier(alias) ? alias : JSON.stringify(alias);
         inputLines.push(`    ${aliasKey}: ${valueType};`);
@@ -74,16 +74,27 @@ ${inputLines.join("\n")}
  * to `unknown` rather than throwing — the server's deploy-time schema parse
  * catches structurally-invalid declarations before they reach us.
  */
-export function inputsToType(inputs) {
+export function inputsToType(inputs, opts) {
+    // A WORKFLOW optional input also accepts `null` — the diff-write "clear this
+    // field" signal (the backend validates it, the body forwards it to
+    // `update_records({ set: { fld: null } })`). So `useWorkflow` call sites can
+    // pass `null` to unset a field without a loose `Record<string, unknown>` cast.
+    // Query params + agent inputs have no "clear", so they stay `T` (the caller
+    // omits the flag). Only the TOP level is nullable: a nested object's optional
+    // field mirrors the backend's plain `.optional()` (the recursive call below
+    // omits the flag), so the type never claims a nested clear the server rejects.
+    const nullableOptional = opts?.nullableOptional === true;
     const fields = [];
     for (const [key, decl] of Object.entries(inputs)) {
         if (decl === null || typeof decl !== "object")
             continue;
         const d = decl;
         const tsType = inputDeclToTsType(d);
-        const optional = d.required === false ? "?" : "";
+        const isOptional = d.required === false;
+        const fieldType = isOptional && nullableOptional ? `${tsType} | null` : tsType;
+        const optional = isOptional ? "?" : "";
         const fieldKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-        fields.push(`      ${fieldKey}${optional}: ${tsType};`);
+        fields.push(`      ${fieldKey}${optional}: ${fieldType};`);
     }
     if (fields.length === 0)
         return "Record<string, never>";

package/dist/generate_app_workflows_dts.test.js

@@ -58,6 +58,32 @@ describe("generateAppWorkflowsDts", () => {
         expect(dts).toContain("note?: string;");
         expect(dts).toContain("ref: string;");
     });
+    it("types a TOP-LEVEL optional workflow input as `T | null` (the diff-write clear signal), required stays `T`, nested stays plain optional", () => {
+        const dts = generateAppWorkflowsDts({
+            updateTask: {
+                workflow_id: "wfl_u",
+                inputs: {
+                    record_id: { type: "record_link", table_id: "tbl_x" },
+                    due: { type: "date", required: false },
+                    status: { type: "select", required: false, options: [{ label: "Done", value: "opt_done" }] },
+                    tags: { type: "select", multi: true, required: false, options: [{ label: "A", value: "opt_a" }] },
+                    meta: {
+                        type: "object",
+                        required: false,
+                        fields: { note: { type: "text", required: false } },
+                    },
+                },
+            },
+        });
+        expect(dts).toContain("record_id: string;"); // required → NOT nullable
+        expect(dts).toContain("due?: string | null;"); // optional scalar → clearable
+        expect(dts).toContain('status?: "opt_done" | null;');
+        expect(dts).toContain('tags?: ReadonlyArray<"opt_a"> | null;'); // optional multi
+        // The object itself is a top-level optional → nullable; its NESTED optional
+        // field mirrors the backend's plain `.optional()` (no `| null`).
+        expect(dts).toContain("note?: string;");
+        expect(dts).not.toContain("note?: string | null;");
+    });
     it("maps record_link/select outputs the same way as inputs", () => {
         const dts = generateAppWorkflowsDts({
             lookup: {

package/dist/src/cli.js

@@ -29704,6 +29704,9 @@ var LoticsClient = class {
   async createWorkspace(body) {
     return this.request("POST", "/v1/workspaces", body);
   }
+  async deleteWorkspace(id) {
+    return this.request("DELETE", `/v1/workspaces/${encodeURIComponent(id)}`);
+  }
   async login() {
     return this.request("POST", "/v1/cli/login");
   }
@@ -30638,10 +30641,18 @@ export default defineConfig({
             // the hooks dispatcher the instant a hook (useAgentRun / useQuery)
             // runs in a rendered App tree.
             "@lotics/app-sdk",
+            // The /router subpath is a SEPARATE optimizer entry \u2014 without it,
+            // AppRouter's BrowserRouter bundles apart from the app's
+            // react-router hooks and the Router context never matches
+            // ("useNavigate() may be used only in the context of a <Router>").
+            "@lotics/app-sdk/router",
             // react-router-dom (App's router) also ships compiled dist JS \u2014 pin it
             // into the shared chunk so its hooks don't split the react instance
             // ("Invalid hook call") when a test renders the routed App tree.
             "react-router-dom",
+            // v7: react-router-dom is a thin wrapper \u2014 the actual context
+            // lives in react-router; both must ride the shared chunk.
+            "react-router",
           ],
           esbuildOptions: {
             resolveExtensions: [".web.tsx", ".web.ts", ".web.js", ".tsx", ".ts", ".jsx", ".js", ".json"],
@@ -31748,7 +31759,7 @@ declare module "@lotics/app-sdk" {
   const inputLines = [];
   const resultLines = [];
   for (const [alias, declaration] of entries) {
-    const valueType = declaration.inputs ? inputsToType(declaration.inputs) : "Record<string, unknown>";
+    const valueType = declaration.inputs ? inputsToType(declaration.inputs, { nullableOptional: true }) : "Record<string, unknown>";
     const aliasKey = isValidIdentifier(alias) ? alias : JSON.stringify(alias);
     inputLines.push(`    ${aliasKey}: ${valueType};`);
     if (declaration.outputs) {
@@ -31767,15 +31778,18 @@ ${inputLines.join("\n")}
 }
 `;
 }
-function inputsToType(inputs) {
+function inputsToType(inputs, opts) {
+  const nullableOptional = opts?.nullableOptional === true;
   const fields = [];
   for (const [key, decl] of Object.entries(inputs)) {
     if (decl === null || typeof decl !== "object") continue;
     const d = decl;
     const tsType = inputDeclToTsType(d);
-    const optional = d.required === false ? "?" : "";
+    const isOptional = d.required === false;
+    const fieldType = isOptional && nullableOptional ? `${tsType} | null` : tsType;
+    const optional = isOptional ? "?" : "";
     const fieldKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-    fields.push(`      ${fieldKey}${optional}: ${tsType};`);
+    fields.push(`      ${fieldKey}${optional}: ${fieldType};`);
   }
   if (fields.length === 0) return "Record<string, never>";
   return `{
@@ -33164,6 +33178,7 @@ function parseArgs(argv) {
     message: void 0,
     local: false,
     all: false,
+    yes: false,
     printCreated: false,
     cleanup: false,
     version: false,
@@ -33219,6 +33234,10 @@ function parseArgs(argv) {
       case "--all":
         flags.all = true;
         break;
+      case "--yes":
+      case "-y":
+        flags.yes = true;
+        break;
       case "--print-created":
       case "--report-effects":
         flags.printCreated = true;
@@ -49681,6 +49700,7 @@ COMMANDS
   lotics workspace                     List workspaces in the active org (marks current)
   lotics workspace select <id>         Switch to a different workspace
   lotics workspace create <name>       Create a new workspace (admin only)
+  lotics workspace delete <id> --yes   Delete a workspace (admin only; soft delete, recoverable)
   lotics tools                         List all available tools
   lotics tools <name>                  Show tool description and input schema
   lotics run <tool> '<json>'           Execute a tool
@@ -50261,9 +50281,39 @@ Available workspaces:`);
       }
       return;
     }
+    if (subcommand === "delete") {
+      const targetId = toolArgs;
+      if (!targetId) {
+        console.error("Usage: lotics workspace delete <workspace_id> --yes");
+        process.exit(1);
+      }
+      const target = workspaces.find((ws) => ws.id === targetId);
+      if (!target) {
+        console.error(`Workspace not found: ${targetId}
+
+Available workspaces:`);
+        printWorkspaceList(workspaces, currentWorkspaceId);
+        process.exit(1);
+      }
+      if (!flags.yes) {
+        console.error(`This deletes workspace "${target.name}" (${target.id}) \u2014 every table, app, record, and template inside it becomes inaccessible (soft delete: retained and recoverable by an admin).`);
+        console.error(`Re-run with --yes to confirm:  lotics workspace delete ${target.id} --yes`);
+        process.exit(1);
+      }
+      const deleted = await client.deleteWorkspace(target.id);
+      if (flags.json) {
+        console.log(JSON.stringify(deleted, null, 2));
+      } else {
+        console.error(`Deleted workspace: ${target.name} (${target.id})`);
+        if (currentWorkspaceId === target.id) {
+          console.error('This was your selected workspace \u2014 select another with "lotics workspace select <id>".');
+        }
+      }
+      return;
+    }
     if (subcommand && subcommand !== "list") {
       console.error(`Unknown workspace subcommand: ${subcommand}`);
-      console.error("Usage: lotics workspace [list | select <id> | create <name>]");
+      console.error("Usage: lotics workspace [list | select <id> | create <name> | delete <id> --yes]");
       process.exit(1);
     }
     if (flags.json) {

package/dist/starter_template.js

@@ -316,10 +316,18 @@ export default defineConfig({
             // the hooks dispatcher the instant a hook (useAgentRun / useQuery)
             // runs in a rendered App tree.
             "@lotics/app-sdk",
+            // The /router subpath is a SEPARATE optimizer entry — without it,
+            // AppRouter's BrowserRouter bundles apart from the app's
+            // react-router hooks and the Router context never matches
+            // ("useNavigate() may be used only in the context of a <Router>").
+            "@lotics/app-sdk/router",
             // react-router-dom (App's router) also ships compiled dist JS — pin it
             // into the shared chunk so its hooks don't split the react instance
             // ("Invalid hook call") when a test renders the routed App tree.
             "react-router-dom",
+            // v7: react-router-dom is a thin wrapper — the actual context
+            // lives in react-router; both must ride the shared chunk.
+            "react-router",
           ],
           esbuildOptions: {
             resolveExtensions: [".web.tsx", ".web.ts", ".web.js", ".tsx", ".ts", ".jsx", ".js", ".json"],

package/package.json

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