@cobinar/dalus 0.1.8 → 0.1.11

package/README.md

@@ -18,53 +18,27 @@ relying on this day to day.
 
 ## Install
 
-```
-npm install -g @cobinar/dalus
-```
-
-Or from source, for working on dalus itself:
-
 ```
 cd dalus
 npm install
 npm link   # makes the `dalus` command available globally
 ```
 
+(Not published to npm — this is source you own and can change.)
+
 ## Log in
 
 ```
-dalus login
+dalus login --api-base https://worker.lobby.cobinar.com --token <your bearer token>
 ```
 
-Opens your browser to sign in with Cobinar (the same sign-in every
-cobinar.com visitor uses — dalus doesn't have, and doesn't need, its own
-separate login), then stores what it gets back in
-`~/.dalus/credentials.json` (mode 0600), never inside a project
-directory. You'll also be asked for your dashboard-worker URL the first
-time — `dalus login --api-base <url>` to skip that prompt.
-
-Mechanically: dalus starts a one-shot local server on an ephemeral port,
-opens `https://cobinar.com/cli-login?port=<port>&ls=<random>`, and waits.
-That page runs the exact same auth.cobinar.com round trip as a normal
-sign-in; once it succeeds, cobinar.com's own `/auth/callback` page POSTs a
-short-lived, single-use code to dalus's local server (proving it's
-genuinely that page, not some other local process, via the `ls` value).
-dalus then redeems that code itself, directly against
-`cobinar-developers-worker`'s `/auth/redeem-code` (override with
-`--developers-base` for staging), which is what actually mints the
-signed token dashboard-worker checks — cobinar.com's callback never
-holds or sees that token, only the one-time code. No separate OAuth
-client, no manually copying anything out of a browser session.
-
-The stored token lasts 2 hours (`cobinar-developers-worker` sets that
-expiry) — `dalus login` again once a command starts failing with a
-session-expired error.
-
-`--token <token> [--api-base <url>]` is kept as a manual fallback for a
-CI runner or a headless box with no browser to open — get a token some
-other way and hand it to dalus directly, the same way `gh auth login
---with-token` works. A real headless flow (a one-time code, email
-verification) is planned but not built yet.
+dalus doesn't implement Cobinar's own signup/login flow — that lives in
+`cobinar-developers-worker`, a separate system. This command stores a
+token you've already obtained from wherever that flow gives you one, the
+same way `gh auth login --with-token` accepts a token instead of
+reimplementing GitHub's own login. Omit `--api-base`/`--token` to be
+prompted instead. Credentials are stored in `~/.dalus/credentials.json`
+(mode 0600), never inside a project directory.
 
 `dalus login --whoami` shows what's currently stored (token
 redacted). `dalus login --logout` clears it.

package/bin/{dalus.js → dalus.mjs}

@@ -1,25 +1,20 @@
 #!/usr/bin/env node
 'use strict';
 
-const { loginCommand } = require('../src/commands/login');
-const { forgeCommand } = require('../src/commands/forge');
-const { initCommand } = require('../src/commands/init');
+import { loginCommand } from '../src/commands/login.mjs';
+import { forgeCommand } from '../src/commands/forge.mjs';
+import { initCommand } from '../src/commands/init.mjs';
 
 const HELP = `dalus — deploy Cobinar projects from the command line
 
 Usage:
-  dalus login [--web-base <url>] [--api-base <url>]
-  dalus login --token <token> [--api-base <url>]
+  dalus login [--api-base <url>] [--token <token>]
   dalus login --whoami
   dalus login --logout
   dalus init [--force]
   dalus forge [--pages] [--workers] [--storage] [--database] [--vault]
               [--env <name>] [--name <resourceName>] [--yes]
 
-  Bare "dalus login" opens your browser to sign in with Cobinar and stores
-  what it gets back. --token accepts one you already have some other way
-  (CI, a headless box with no browser) instead.
-
   Bare "dalus forge" deploys every resource in dalus.jsonc / dalus.toml /
   dalus.json found in the current directory. Passing one or more of
   --pages/--workers/--storage/--database/--vault narrows it to just
@@ -60,10 +55,6 @@ async function main() {
 }
 
 main().catch((err) => {
-  if (err && err.status === 401) {
-    console.error('Your Cobinar session expired or was rejected. Run "dalus login" again.');
-  } else {
-    console.error(err.message || err);
-  }
+  console.error(err.message || err);
   process.exitCode = 1;
 });

package/convert_to_mjs.py

@@ -0,0 +1,59 @@
+import os
+import re
+
+TARGET_DIR = r"D:\Downloads\daluss"
+
+# Directories to skip to prevent corrupting dependencies or git history
+IGNORE_DIRS = {'node_modules', '.git', 'dist', 'build'}
+
+def convert_js_to_mjs(directory):
+    if not os.path.exists(directory):
+        print(f"Error: Directory '{directory}' does not exist.")
+        return
+
+    js_files = []
+
+    # 1. Collect all .js file paths
+    for root, dirs, files in os.walk(directory):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        for file in files:
+            if file.endswith('.js'):
+                js_files.append(os.path.join(root, file))
+
+    print(f"Found {len(js_files)} .js files in '{directory}'...\n")
+
+    # Regex matches relative imports/exports/requires pointing to .js files (e.g., './utils.js' -> './utils.mjs')
+    import_regex = re.compile(r'(import|export|require)\b([^"\']*["\']\.\.?[^"\']*)\.js(["\'])')
+
+    # 2. Update relative import paths inside all relevant files
+    for root, dirs, files in os.walk(directory):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        for file in files:
+            if file.endswith(('.js', '.mjs', '.ts', '.json')):
+                file_path = os.path.join(root, file)
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+
+                    updated_content = import_regex.sub(r'\1\2.mjs\3', content)
+
+                    if updated_content != content:
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(updated_content)
+                        print(f"[UPDATED IMPORTS] {file_path}")
+                except Exception as e:
+                    print(f"[SKIPPED FILE READ/WRITE] {file_path}: {e}")
+
+    # 3. Rename .js files to .mjs
+    for old_path in js_files:
+        new_path = old_path[:-3] + '.mjs'
+        try:
+            os.rename(old_path, new_path)
+            print(f"[RENAMED] {os.path.basename(old_path)} -> {os.path.basename(new_path)}")
+        except Exception as e:
+            print(f"[RENAME FAILED] {old_path}: {e}")
+
+    print("\nConversion complete!")
+
+if __name__ == "__main__":
+    convert_js_to_mjs(TARGET_DIR)

package/fix_requires.py

@@ -0,0 +1,57 @@
+import os
+import re
+
+TARGET_DIR = r"D:\Downloads\daluss"
+IGNORE_DIRS = {'node_modules', '.git', 'dist', 'build'}
+
+def fix_exports(directory):
+    if not os.path.exists(directory):
+        print(f"Error: Directory '{directory}' does not exist.")
+        return
+
+    # Matches: module.exports = { something };
+    exports_dict_regex = re.compile(r"module\.exports\s*=\s*\{([^}]+)\}\s*;?")
+    
+    # Matches: module.exports.foo = bar; or exports.foo = bar;
+    named_exports_regex = re.compile(r"(?:module\.)?exports\.([a-zA-Z0-9_]+)\s*=\s*")
+    
+    # Matches: module.exports = myVariable; (for default exports)
+    default_export_regex = re.compile(r"module\.exports\s*=\s*([a-zA-Z0-9_]+)\s*;?")
+
+    changed_files_count = 0
+
+    for root, dirs, files in os.walk(directory):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        
+        for file in files:
+            if file.endswith('.mjs'):
+                file_path = os.path.join(root, file)
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+
+                    original_content = content
+                    
+                    # Fix object exports: module.exports = { foo }; -> export { foo };
+                    content = exports_dict_regex.sub(r"export { \1 };", content)
+                    
+                    # Fix named exports: module.exports.foo = ... -> export const foo = ...
+                    content = named_exports_regex.sub(r"export const \1 = ", content)
+                    
+                    # Fix default exports: module.exports = foo; -> export default foo;
+                    content = default_export_regex.sub(r"export default \1;", content)
+
+                    if content != original_content:
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            f.write(content)
+                        print(f"[FIXED EXPORTS] {file_path}")
+                        changed_files_count += 1
+
+                except Exception as e:
+                    print(f"[SKIPPED] {file_path}: {e}")
+
+    print(f"\n✅ Conversion complete! Fixed {changed_files_count} files.")
+
+if __name__ == "__main__":
+    print("Scanning .mjs files to fix CommonJS exports (module.exports)...\n")
+    fix_exports(TARGET_DIR)

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@cobinar/dalus",
-  "version": "0.1.8",
-  "type": "commonjs",
+  "version": "0.1.11",
   "description": "Deploy Cobinar projects (Edge Compute, Static Hosting, Object Storage, Document DB, Vault) from the command line.",
   "bin": {
-    "dalus": "./bin/dalus.js"
+    "dalus": "./bin/dalus.mjs"
   },
   "main": "./src/index.js",
+  "type": "commonjs",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
     "jsonc-parser": "^3.3.1",
-    "smol-toml": "^1.3.1"
+    "smol-toml": "^1.8.0"
   },
   "license": "MIT"
 }

package/publish-dalus.bat

@@ -2,7 +2,7 @@
 echo 🚀 Preparing to publish new @cobinar/dalus version...
 
 :: Navigate to your exact project directory
-cd /d "D:\Downloads\Cobinar-Lobby + Dashboard  + Da;us CLI\dalus"
+cd /d "D:\Downloads\daluss"
 
 echo.
 echo 🔐 Checking npm authentication...

package/src/{api-client.js → api-client.mjs}

@@ -1,67 +1,67 @@
-'use strict';
-// A thin client over cobinar-dashboard-worker's real REST API — every
-// call here hits an endpoint that already exists and is already used by
-// the dashboard itself (see that project's README for the full list).
-// dalus doesn't talk to Cloudflare directly and has no separate deploy
-// mechanism of its own; it's a scriptable front door to the same API the
-// web dashboard calls, nothing more.
-
-class DalusApiError extends Error {
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-  }
-}
-
-class ApiClient {
-  constructor({ apiBase, token }) {
-    if (!apiBase) throw new Error('apiBase is required (set it in your dalus config, or run "dalus login").');
-    if (!token) throw new Error('Not logged in — run "dalus login" first.');
-    this.apiBase = apiBase.replace(/\/$/, '');
-    this.token = token;
-  }
-
-  async request(method, path, { body, headers, rawBody } = {}) {
-    const res = await fetch(`${this.apiBase}${path}`, {
-      method,
-      headers: {
-        authorization: `Bearer ${this.token}`,
-        ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
-        ...headers,
-      },
-      body: rawBody !== undefined ? rawBody : body !== undefined ? JSON.stringify(body) : undefined,
-    });
-    const text = await res.text();
-    let parsed;
-    try { parsed = text ? JSON.parse(text) : null; } catch { parsed = text; }
-    if (!res.ok) {
-      const message = (parsed && typeof parsed === 'object' && parsed.error) || `${method} ${path} failed with ${res.status}`;
-      throw new DalusApiError(message, res.status, parsed);
-    }
-    return parsed;
-  }
-
-  get(path) { return this.request('GET', path); }
-  post(path, body) { return this.request('POST', path, { body }); }
-  patch(path, body) { return this.request('PATCH', path, { body }); }
-  put(path, body) { return this.request('PUT', path, { body }); }
-  delete(path) { return this.request('DELETE', path); }
-  putRaw(path, rawBody, contentType) {
-    return this.request('PUT', path, { rawBody, headers: contentType ? { 'content-type': contentType } : undefined });
-  }
-
-  // ---- find-or-create helpers ----
-  // Every resource kind exposes a GET list + POST create, and every
-  // create schema 400s on a duplicate name scoped the way that resource
-  // scopes names (see each route file) — so "does this already exist"
-  // is answered by listing and matching on name, not a dedicated
-  // lookup-by-name endpoint (none of these APIs have one).
-
-  async findByName(listPath, name) {
-    const rows = await this.get(listPath);
-    return rows.find((r) => r.name === name) || null;
-  }
-}
-
-module.exports = { ApiClient, DalusApiError };
+'use strict';
+// A thin client over cobinar-dashboard-worker's real REST API — every
+// call here hits an endpoint that already exists and is already used by
+// the dashboard itself (see that project's README for the full list).
+// dalus doesn't talk to Cloudflare directly and has no separate deploy
+// mechanism of its own; it's a scriptable front door to the same API the
+// web dashboard calls, nothing more.
+
+class DalusApiError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class ApiClient {
+  constructor({ apiBase, token }) {
+    if (!apiBase) throw new Error('apiBase is required (set it in your dalus config, or run "dalus login").');
+    if (!token) throw new Error('Not logged in — run "dalus login" first.');
+    this.apiBase = apiBase.replace(/\/$/, '');
+    this.token = token;
+  }
+
+  async request(method, path, { body, headers, rawBody } = {}) {
+    const res = await fetch(`${this.apiBase}${path}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+        ...headers,
+      },
+      body: rawBody !== undefined ? rawBody : body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    let parsed;
+    try { parsed = text ? JSON.parse(text) : null; } catch { parsed = text; }
+    if (!res.ok) {
+      const message = (parsed && typeof parsed === 'object' && parsed.error) || `${method} ${path} failed with ${res.status}`;
+      throw new DalusApiError(message, res.status, parsed);
+    }
+    return parsed;
+  }
+
+  get(path) { return this.request('GET', path); }
+  post(path, body) { return this.request('POST', path, { body }); }
+  patch(path, body) { return this.request('PATCH', path, { body }); }
+  put(path, body) { return this.request('PUT', path, { body }); }
+  delete(path) { return this.request('DELETE', path); }
+  putRaw(path, rawBody, contentType) {
+    return this.request('PUT', path, { rawBody, headers: contentType ? { 'content-type': contentType } : undefined });
+  }
+
+  // ---- find-or-create helpers ----
+  // Every resource kind exposes a GET list + POST create, and every
+  // create schema 400s on a duplicate name scoped the way that resource
+  // scopes names (see each route file) — so "does this already exist"
+  // is answered by listing and matching on name, not a dedicated
+  // lookup-by-name endpoint (none of these APIs have one).
+
+  async findByName(listPath, name) {
+    const rows = await this.get(listPath);
+    return rows.find((r) => r.name === name) || null;
+  }
+}
+
+export {  ApiClient, DalusApiError  };

package/src/commands/{forge.js → forge.mjs}

@@ -1,104 +1,104 @@
-'use strict';
-const { loadConfig, resolveEnv, loadCredentials } = require('../config');
-const { ApiClient } = require('../api-client');
-const { forgeWorker } = require('../forgers/workers');
-const { forgePages } = require('../forgers/pages');
-const { forgeStorage } = require('../forgers/storage');
-const { forgeDatabase } = require('../forgers/database');
-const { forgeVault } = require('../forgers/vault');
-
-const KIND_FLAGS = {
-  workers: '--workers',
-  pages: '--pages',
-  storage: '--storage',
-  database: '--database',
-  vault: '--vault',
-};
-const FORGERS = {
-  workers: (api, log, entry, opts) => forgeWorker(api, log, entry, opts),
-  pages: (api, log, entry) => forgePages(api, log, entry),
-  storage: (api, log, entry) => forgeStorage(api, log, entry),
-  database: (api, log, entry) => forgeDatabase(api, log, entry),
-  vault: (api, log, entry) => forgeVault(api, log, entry),
-};
-// Bare `dalus forge` (no kind flags) deploys every kind — in THIS order,
-// not object-key order: storage/database/vault/pages have no
-// dependencies on anything else in this list, while a worker's bindings
-// reference a storage bucket or Document DB collection by name and fail
-// with a clear "doesn't exist yet" error if that resource isn't already
-// forged. Deploying workers last means a bare `dalus forge` on a brand
-// new project just works, instead of depending on running it twice.
-const DEFAULT_KIND_ORDER = ['storage', 'database', 'vault', 'pages', 'workers'];
-
-function parseForgeArgs(args) {
-  const opts = { kinds: [], env: null, yes: args.includes('--yes'), only: null };
-  for (const [kind, flag] of Object.entries(KIND_FLAGS)) {
-    if (args.includes(flag)) opts.kinds.push(kind);
-  }
-  const envIdx = args.indexOf('--env');
-  if (envIdx !== -1) opts.env = args[envIdx + 1];
-  const onlyIdx = args.indexOf('--name');
-  if (onlyIdx !== -1) opts.only = args[onlyIdx + 1]; // deploy just the one resource with this name, across whichever kind(s) it's found under
-  return opts;
-}
-
-// `dalus forge` with no --pages/--workers/etc. deploys every resource
-// kind present in the config — bare `dalus forge` is meant to mean "ship
-// this whole project," matching the exact example in the original ask.
-// Naming one or more kind flags narrows it to just those.
-async function forgeCommand(args) {
-  const opts = parseForgeArgs(args);
-  const creds = loadCredentials();
-  if (!creds) {
-    console.error('Not logged in. Run "dalus login" first.');
-    process.exitCode = 1;
-    return;
-  }
-
-  let config;
-  try {
-    config = loadConfig();
-    if (opts.env) config = resolveEnv(config, opts.env);
-  } catch (err) {
-    console.error(err.message);
-    process.exitCode = 1;
-    return;
-  }
-
-  const api = new ApiClient({ apiBase: config.apiBase || creds.apiBase, token: creds.token });
-  const kindsToRun = opts.kinds.length > 0 ? opts.kinds : DEFAULT_KIND_ORDER;
-
-  const results = [];
-  for (const kind of kindsToRun) {
-    const entries = (config[kind] || []).filter((e) => !opts.only || e.name === opts.only);
-    for (const entry of entries) {
-      try {
-        await FORGERS[kind](api, (line) => console.log(line), entry, opts);
-        results.push({ kind, name: entry.name, ok: true });
-      } catch (err) {
-        console.error(`  FAILED: ${err.message}`);
-        results.push({ kind, name: entry.name, ok: false, error: err.message });
-      }
-      console.log('');
-    }
-  }
-
-  if (results.length === 0) {
-    console.log(
-      opts.kinds.length > 0
-        ? `No ${opts.kinds.join('/')} entries found in ${config.__configPath}.`
-        : `Nothing to deploy — ${config.__configPath} has no workers/pages/storage/database/vault entries.`,
-    );
-    return;
-  }
-
-  const failed = results.filter((r) => !r.ok);
-  console.log(`${results.length - failed.length}/${results.length} deployed successfully.`);
-  if (failed.length > 0) {
-    console.log('Failed:');
-    for (const f of failed) console.log(`  - ${f.kind} ${f.name}: ${f.error}`);
-    process.exitCode = 1;
-  }
-}
-
-module.exports = { forgeCommand };
+'use strict';
+import { loadConfig, resolveEnv, loadCredentials } from '../config.mjs';
+import { ApiClient } from '../api-client.mjs';
+import { forgeWorker } from '../forgers/workers.mjs';
+import { forgePages } from '../forgers/pages.mjs';
+import { forgeStorage } from '../forgers/storage.mjs';
+import { forgeDatabase } from '../forgers/database.mjs';
+import { forgeVault } from '../forgers/vault.mjs';
+
+const KIND_FLAGS = {
+  workers: '--workers',
+  pages: '--pages',
+  storage: '--storage',
+  database: '--database',
+  vault: '--vault',
+};
+const FORGERS = {
+  workers: (api, log, entry, opts) => forgeWorker(api, log, entry, opts),
+  pages: (api, log, entry) => forgePages(api, log, entry),
+  storage: (api, log, entry) => forgeStorage(api, log, entry),
+  database: (api, log, entry) => forgeDatabase(api, log, entry),
+  vault: (api, log, entry) => forgeVault(api, log, entry),
+};
+// Bare `dalus forge` (no kind flags) deploys every kind — in THIS order,
+// not object-key order: storage/database/vault/pages have no
+// dependencies on anything else in this list, while a worker's bindings
+// reference a storage bucket or Document DB collection by name and fail
+// with a clear "doesn't exist yet" error if that resource isn't already
+// forged. Deploying workers last means a bare `dalus forge` on a brand
+// new project just works, instead of depending on running it twice.
+const DEFAULT_KIND_ORDER = ['storage', 'database', 'vault', 'pages', 'workers'];
+
+function parseForgeArgs(args) {
+  const opts = { kinds: [], env: null, yes: args.includes('--yes'), only: null };
+  for (const [kind, flag] of Object.entries(KIND_FLAGS)) {
+    if (args.includes(flag)) opts.kinds.push(kind);
+  }
+  const envIdx = args.indexOf('--env');
+  if (envIdx !== -1) opts.env = args[envIdx + 1];
+  const onlyIdx = args.indexOf('--name');
+  if (onlyIdx !== -1) opts.only = args[onlyIdx + 1]; // deploy just the one resource with this name, across whichever kind(s) it's found under
+  return opts;
+}
+
+// `dalus forge` with no --pages/--workers/etc. deploys every resource
+// kind present in the config — bare `dalus forge` is meant to mean "ship
+// this whole project," matching the exact example in the original ask.
+// Naming one or more kind flags narrows it to just those.
+async function forgeCommand(args) {
+  const opts = parseForgeArgs(args);
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error('Not logged in. Run "dalus login" first.');
+    process.exitCode = 1;
+    return;
+  }
+
+  let config;
+  try {
+    config = loadConfig();
+    if (opts.env) config = resolveEnv(config, opts.env);
+  } catch (err) {
+    console.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  const api = new ApiClient({ apiBase: config.apiBase || creds.apiBase, token: creds.token });
+  const kindsToRun = opts.kinds.length > 0 ? opts.kinds : DEFAULT_KIND_ORDER;
+
+  const results = [];
+  for (const kind of kindsToRun) {
+    const entries = (config[kind] || []).filter((e) => !opts.only || e.name === opts.only);
+    for (const entry of entries) {
+      try {
+        await FORGERS[kind](api, (line) => console.log(line), entry, opts);
+        results.push({ kind, name: entry.name, ok: true });
+      } catch (err) {
+        console.error(`  FAILED: ${err.message}`);
+        results.push({ kind, name: entry.name, ok: false, error: err.message });
+      }
+      console.log('');
+    }
+  }
+
+  if (results.length === 0) {
+    console.log(
+      opts.kinds.length > 0
+        ? `No ${opts.kinds.join('/')} entries found in ${config.__configPath}.`
+        : `Nothing to deploy — ${config.__configPath} has no workers/pages/storage/database/vault entries.`,
+    );
+    return;
+  }
+
+  const failed = results.filter((r) => !r.ok);
+  console.log(`${results.length - failed.length}/${results.length} deployed successfully.`);
+  if (failed.length > 0) {
+    console.log('Failed:');
+    for (const f of failed) console.log(`  - ${f.kind} ${f.name}: ${f.error}`);
+    process.exitCode = 1;
+  }
+}
+
+export {  forgeCommand  };