@cobinar/dalus 0.1.10 → 0.1.12

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

@@ -1,9 +1,9 @@
 #!/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
 

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,9 +1,9 @@
 {
   "name": "@cobinar/dalus",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "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",
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "jsonc-parser": "^3.3.1",
-    "smol-toml": "^1.3.1"
+    "smol-toml": "^1.8.0"
   },
   "license": "MIT"
 }

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  };

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

@@ -1,53 +1,53 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-
-const TEMPLATE = `{
-  // dalus config — see https://github.com/ (your Cobinar docs link here)
-  // for the full field reference. Paths below are relative to this file.
-
-  // Optional — if omitted, dalus uses whatever worker URL you logged in
-  // with ("dalus login"). Set this when a project should always deploy
-  // to a specific worker regardless of who's running "dalus forge".
-  // "apiBase": "https://worker.lobby.cobinar.com",
-
-  "workers": [
-    // { "name": "my-api", "main": "./worker.js",
-    //   "bindings": [
-    //     { "name": "MY_BUCKET", "type": "storage", "resource": "my-bucket" }
-    //   ],
-    //   "secrets": ["SOME_API_KEY"] }
-  ],
-  "pages": [
-    // { "name": "my-site", "dir": "./public" }
-  ],
-  "storage": [
-    // { "name": "my-bucket", "dir": "./assets", "public": true }
-  ],
-  "database": [
-    // { "name": "my_collection", "seed": "./seed.json" }
-  ],
-  "vault": [
-    // { "name": "my-vault", "rules": "./rules.txt" }
-  ]
-
-  // Named environments (optional) — "dalus forge --env staging" uses
-  // these instead of the top-level lists above, per resource kind:
-  // "env": {
-  //   "staging": { "workers": [ { "name": "my-api-staging", "main": "./worker.js" } ] }
-  // }
-}
-`;
-
-function initCommand(args) {
-  const target = path.join(process.cwd(), 'dalus.jsonc');
-  if (fs.existsSync(target) && !args.includes('--force')) {
-    console.error(`${target} already exists — pass --force to overwrite.`);
-    process.exitCode = 1;
-    return;
-  }
-  fs.writeFileSync(target, TEMPLATE);
-  console.log(`Created ${target}. Fill in the resources you want, then run "dalus forge".`);
-}
-
-module.exports = { initCommand };
+'use strict';
+import fs from 'fs';
+import path from 'path';
+
+const TEMPLATE = `{
+  // dalus config — see https://github.com/ (your Cobinar docs link here)
+  // for the full field reference. Paths below are relative to this file.
+
+  // Optional — if omitted, dalus uses whatever worker URL you logged in
+  // with ("dalus login"). Set this when a project should always deploy
+  // to a specific worker regardless of who's running "dalus forge".
+  // "apiBase": "https://worker.lobby.cobinar.com",
+
+  "workers": [
+    // { "name": "my-api", "main": "./worker.js",
+    //   "bindings": [
+    //     { "name": "MY_BUCKET", "type": "storage", "resource": "my-bucket" }
+    //   ],
+    //   "secrets": ["SOME_API_KEY"] }
+  ],
+  "pages": [
+    // { "name": "my-site", "dir": "./public" }
+  ],
+  "storage": [
+    // { "name": "my-bucket", "dir": "./assets", "public": true }
+  ],
+  "database": [
+    // { "name": "my_collection", "seed": "./seed.json" }
+  ],
+  "vault": [
+    // { "name": "my-vault", "rules": "./rules.txt" }
+  ]
+
+  // Named environments (optional) — "dalus forge --env staging" uses
+  // these instead of the top-level lists above, per resource kind:
+  // "env": {
+  //   "staging": { "workers": [ { "name": "my-api-staging", "main": "./worker.js" } ] }
+  // }
+}
+`;
+
+function initCommand(args) {
+  const target = path.join(process.cwd(), 'dalus.jsonc');
+  if (fs.existsSync(target) && !args.includes('--force')) {
+    console.error(`${target} already exists — pass --force to overwrite.`);
+    process.exitCode = 1;
+    return;
+  }
+  fs.writeFileSync(target, TEMPLATE);
+  console.log(`Created ${target}. Fill in the resources you want, then run "dalus forge".`);
+}
+
+export {  initCommand  };