@ductape/cli 0.2.0 → 0.2.1

package/dist/lib/templates.js

@@ -47,7 +47,7 @@ DUCTAPE_ENV=dev
     const envPath = path.join(dir, '.env.ductape.example');
     if (!fs.existsSync(envPath))
         fs.writeFileSync(envPath, envContent);
-    const ductapeDir = path.join(dir, '.ductape');
+    const ductapeDir = path.join(dir, 'ductape');
     fs.mkdirSync(ductapeDir, { recursive: true });
     const readme = `# Ductape project
 
@@ -63,6 +63,80 @@ Docs: https://docs.ductape.app/docs/cli/
     const readmePath = path.join(ductapeDir, 'README.md');
     if (!fs.existsSync(readmePath))
         fs.writeFileSync(readmePath, readme);
+    const dbDir = path.join(ductapeDir, 'database');
+    const migrationsDir = path.join(dbDir, 'migrations');
+    fs.mkdirSync(migrationsDir, { recursive: true });
+    const schemaPath = path.join(dbDir, 'schema.json');
+    if (!fs.existsSync(schemaPath)) {
+        const schemaTemplate = [
+            {
+                db: 'your_db_tag',
+                tables: {
+                    example_table: {
+                        id: { type: 'String', primaryKey: true, autoGenerate: true },
+                        name: { type: 'String', required: true },
+                        createdAt: { type: 'Date', default: 'now' },
+                    },
+                },
+            },
+        ];
+        fs.writeFileSync(schemaPath, JSON.stringify(schemaTemplate, null, 2) + '\n');
+    }
+    const sessionsPath = path.join(ductapeDir, 'sessions.json');
+    if (!fs.existsSync(sessionsPath)) {
+        const sessionsTemplate = [
+            {
+                tag: 'user-session',
+                name: 'User session',
+                description: 'Standard authenticated user session',
+                expiry: 604800,
+                refresh_expiry: 2592000,
+            },
+        ];
+        fs.writeFileSync(sessionsPath, JSON.stringify(sessionsTemplate, null, 2) + '\n');
+    }
+    const notificationsPath = path.join(ductapeDir, 'notifications.json');
+    if (!fs.existsSync(notificationsPath)) {
+        const notificationsTemplate = [
+            {
+                tag: 'transactional-email',
+                name: 'Transactional email',
+                description: 'Email channel for transactional messages',
+                envs: [
+                    {
+                        slug: 'dev',
+                        emails: {
+                            host: 'smtp.example.com',
+                            port: 587,
+                            user: 'your-smtp-user',
+                            pass: 'your-smtp-pass',
+                            sender: 'no-reply@example.com',
+                        },
+                    },
+                ],
+            },
+        ];
+        fs.writeFileSync(notificationsPath, JSON.stringify(notificationsTemplate, null, 2) + '\n');
+    }
+    const eventsPath = path.join(ductapeDir, 'events.json');
+    if (!fs.existsSync(eventsPath)) {
+        const eventsTemplate = [
+            {
+                tag: 'main-event-bus',
+                name: 'Main event bus',
+                description: 'Primary message broker for application events',
+                envs: [
+                    {
+                        slug: 'dev',
+                        type: 'kafka',
+                        brokers: ['localhost:9092'],
+                        client_id: 'my-app-dev',
+                    },
+                ],
+            },
+        ];
+        fs.writeFileSync(eventsPath, JSON.stringify(eventsTemplate, null, 2) + '\n');
+    }
     copyTemplate(lang, dir);
     const gitignorePath = path.join(dir, '.gitignore');
     if (fs.existsSync(gitignorePath)) {

package/ductape.example.ts

@@ -0,0 +1,18 @@
+/**
+ * Ductape SDK example — product/env defaults are set on the constructor only.
+ * CLI: `ductape login` + `ductape link` (see .ductape/config.json).
+ */
+import Ductape from '@ductape/sdk';
+
+const ductape = new Ductape({
+  accessKey: process.env.DUCTAPE_ACCESS_KEY!,
+  product: process.env.DUCTAPE_PRODUCT!,
+  env: process.env.DUCTAPE_ENV ?? 'dev',
+});
+
+async function main() {
+  // await ductape.databases.connect({ database: 'main-db' });
+  console.log('Ductape client ready');
+}
+
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/apply.ts

@@ -0,0 +1,105 @@
+import { findProjectConfig } from '../lib/config.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { fail } from '../lib/output.js';
+import { buildCrudParams } from '../lib/resources.js';
+import {
+  loadSessions,
+  loadNotifications,
+  loadEvents,
+  type ApplyItem,
+} from '../lib/apply-loaders.js';
+import type { SDKModule } from '../lib/proxy/sdk-proxy.js';
+
+export type ApplyType = 'sessions' | 'notifications' | 'events';
+
+interface ApplyOpts {
+  dryRun?: boolean;
+}
+
+const MODULE_FOR: Record<ApplyType, SDKModule> = {
+  sessions: 'sessions',
+  notifications: 'notifications',
+  events: 'messageBrokers',
+};
+
+async function syncItems(
+  type: ApplyType,
+  items: ApplyItem[],
+  productTag: string,
+  proxy: ReturnType<typeof getSdkProxy>,
+  dryRun: boolean,
+): Promise<void> {
+  const module = MODULE_FOR[type];
+
+  const listResult = await proxy.execute<unknown>(module, 'list', buildCrudParams(module, 'list', productTag, {}));
+  const existingList = Array.isArray(listResult) ? listResult : [];
+  const existingTags = new Set(
+    existingList.map((r) => (r as { tag?: string }).tag ?? '').filter(Boolean),
+  );
+
+  for (const item of items) {
+    if (!item.tag) {
+      console.warn(`  [${type}] skipped — missing "tag" field`);
+      continue;
+    }
+
+    const verb: 'create' | 'update' = existingTags.has(item.tag) ? 'update' : 'create';
+
+    if (dryRun) {
+      console.log(`  [${type}] would ${verb}: ${item.tag}`);
+      continue;
+    }
+
+    try {
+      const params = buildCrudParams(module, verb, productTag, { tag: item.tag, body: item });
+      await proxy.execute(module, verb, params);
+      console.log(`  [${type}] ${verb}d: ${item.tag}`);
+    } catch (err) {
+      console.error(
+        `  [${type}] ${verb} failed for "${item.tag}": ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+}
+
+export async function runApply(type: ApplyType | undefined, opts: ApplyOpts): Promise<void> {
+  const found = findProjectConfig();
+  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
+
+  const { dir } = found;
+  const session = requireSession();
+  const proxy = getSdkProxy(session);
+  const productTag = session.project.product_tag;
+  const dryRun = Boolean(opts.dryRun);
+
+  const targets: ApplyType[] = type ? [type] : ['sessions', 'notifications', 'events'];
+
+  const loaders: Record<ApplyType, () => ApplyItem[] | null> = {
+    sessions: () => loadSessions(dir),
+    notifications: () => loadNotifications(dir),
+    events: () => loadEvents(dir),
+  };
+
+  for (const t of targets) {
+    let items: ApplyItem[] | null;
+    try {
+      items = loaders[t]();
+    } catch (err) {
+      console.error(`[${t}] parse error: ${err instanceof Error ? err.message : String(err)}`);
+      continue;
+    }
+
+    if (items === null) {
+      console.log(`[${t}] no ductape/${t}.json found — skipping`);
+      continue;
+    }
+
+    if (items.length === 0) {
+      console.log(`[${t}] empty — nothing to apply`);
+      continue;
+    }
+
+    console.log(`[${t}] applying ${items.length} item(s)${dryRun ? ' (dry run)' : ''}...`);
+    await syncItems(t, items, productTag, proxy, dryRun);
+  }
+}

package/src/commands/db-migrate.ts

@@ -0,0 +1,211 @@
+import { findProjectConfig } from '../lib/config.js';
+import { loadSchemaFile } from '../lib/schema-loader.js';
+import { loadMigrationFiles } from '../lib/migration-files.js';
+import { getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { fail, printJson } from '../lib/output.js';
+import type { DatabaseContext } from '../lib/context-store.js';
+
+interface MigrateOpts {
+  env?: string;
+  db?: string;
+  dryRun?: boolean;
+}
+
+interface MigrateStatusOpts {
+  env?: string;
+  db?: string;
+  json?: boolean;
+}
+
+interface MigrateRollbackOpts {
+  env?: string;
+  db?: string;
+  n?: number;
+}
+
+function buildDbContext(dbTag: string, envSlug: string, productTag: string): DatabaseContext {
+  return { database: dbTag, env: envSlug, product: productTag };
+}
+
+async function getAppliedTags(
+  proxy: ReturnType<typeof getDbProxy>,
+  dbContext: DatabaseContext,
+  productTag: string,
+  envSlug: string,
+): Promise<string[]> {
+  try {
+    const result = await proxy.execute<unknown>(
+      'migration.list',
+      [{ product: productTag, env: envSlug, database: dbContext.database }],
+      dbContext,
+    );
+    const list = Array.isArray(result)
+      ? result
+      : Array.isArray((result as { data?: unknown[] }).data)
+        ? (result as { data: unknown[] }).data
+        : [];
+    return (list as Array<{ tag?: string }>).map((r) => r.tag ?? '').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export async function runDbMigrate(opts: MigrateOpts): Promise<void> {
+  const found = findProjectConfig();
+  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
+
+  const { dir } = found;
+  const session = requireSession();
+  const proxy = getDbProxy(session);
+  const envSlug = opts.env ?? session.project.env_slug;
+  const productTag = session.project.product_tag;
+
+  const schemaEntries = loadSchemaFile(dir);
+  const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+
+  if (targets.length === 0) {
+    fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
+  }
+
+  let totalApplied = 0;
+  let totalDry = 0;
+
+  for (const entry of targets) {
+    const { db } = entry;
+    const dbContext = buildDbContext(db, envSlug, productTag);
+    const migrations = loadMigrationFiles(dir, db);
+
+    if (migrations.length === 0) {
+      console.log(`[${db}] No migration files found. Run \`ductape db schema generate\` first.`);
+      continue;
+    }
+
+    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+    const pending = migrations.filter((m) => !appliedTags.includes(m.tag));
+
+    if (pending.length === 0) {
+      console.log(`[${db}] Already up to date.`);
+      continue;
+    }
+
+    console.log(`[${db}] ${pending.length} pending migration(s).`);
+
+    for (const migration of pending) {
+      if (opts.dryRun) {
+        console.log(`  [dry-run] Would apply: ${migration.tag}`);
+        totalDry++;
+        continue;
+      }
+
+      process.stdout.write(`  Applying ${migration.tag}... `);
+      try {
+        await proxy.execute(
+          'migration.run',
+          [{ product: productTag, env: envSlug, database: db, migrations: [migration] }],
+          dbContext,
+        );
+        console.log('done');
+        totalApplied++;
+      } catch (err) {
+        console.log('failed');
+        fail(`Migration "${migration.tag}" failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
+  if (opts.dryRun) {
+    console.log(`\nDry run: ${totalDry} migration(s) would be applied.`);
+  } else {
+    console.log(`\nApplied ${totalApplied} migration(s).`);
+  }
+}
+
+export async function runDbMigrateStatus(opts: MigrateStatusOpts): Promise<void> {
+  const found = findProjectConfig();
+  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
+
+  const { dir } = found;
+  const session = requireSession();
+  const proxy = getDbProxy(session);
+  const envSlug = opts.env ?? session.project.env_slug;
+  const productTag = session.project.product_tag;
+
+  const schemaEntries = loadSchemaFile(dir);
+  const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+
+  const statusReport: Record<string, { applied: string[]; pending: string[] }> = {};
+
+  for (const entry of targets) {
+    const { db } = entry;
+    const dbContext = buildDbContext(db, envSlug, productTag);
+    const migrations = loadMigrationFiles(dir, db);
+    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+
+    const applied = migrations.filter((m) => appliedTags.includes(m.tag)).map((m) => m.tag);
+    const pending = migrations.filter((m) => !appliedTags.includes(m.tag)).map((m) => m.tag);
+
+    statusReport[db] = { applied, pending };
+
+    if (!opts.json) {
+      console.log(`\n[${db}]`);
+      if (applied.length > 0) {
+        console.log(`  Applied (${applied.length}):`);
+        for (const t of applied) console.log(`    + ${t}`);
+      }
+      if (pending.length > 0) {
+        console.log(`  Pending (${pending.length}):`);
+        for (const t of pending) console.log(`    - ${t}`);
+      }
+      if (applied.length === 0 && pending.length === 0) {
+        console.log('  No migration files found.');
+      }
+    }
+  }
+
+  if (opts.json) printJson(statusReport, true);
+}
+
+export async function runDbMigrateRollback(opts: MigrateRollbackOpts): Promise<void> {
+  const found = findProjectConfig();
+  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
+
+  const { dir } = found;
+  const session = requireSession();
+  const proxy = getDbProxy(session);
+  const envSlug = opts.env ?? session.project.env_slug;
+  const productTag = session.project.product_tag;
+  const rollbackCount = opts.n ?? 1;
+
+  const schemaEntries = loadSchemaFile(dir);
+  const targets = opts.db ? schemaEntries.filter((e) => e.db === opts.db) : schemaEntries;
+
+  for (const entry of targets) {
+    const { db } = entry;
+    const dbContext = buildDbContext(db, envSlug, productTag);
+    const migrations = loadMigrationFiles(dir, db);
+    const appliedTags = await getAppliedTags(proxy, dbContext, productTag, envSlug);
+
+    const applied = migrations.filter((m) => appliedTags.includes(m.tag));
+    const toRollback = applied.slice(-rollbackCount).reverse();
+
+    if (toRollback.length === 0) {
+      console.log(`[${db}] Nothing to roll back.`);
+      continue;
+    }
+
+    for (const migration of toRollback) {
+      process.stdout.write(`  Rolling back ${migration.tag}... `);
+      try {
+        await proxy.execute(
+          'migration.rollback',
+          [{ product: productTag, env: envSlug, database: db, migrations: [migration] }],
+          dbContext,
+        );
+        console.log('done');
+      } catch (err) {
+        console.log('failed');
+        fail(`Rollback of "${migration.tag}" failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+}

package/src/commands/db-schema.ts

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import { findProjectConfig } from '../lib/config.js';
+import { loadSchemaFile, parseTableDef } from '../lib/schema-loader.js';
+import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
+import { fail } from '../lib/output.js';
+import type {
+  IMigration,
+  IMigrationOperation,
+  ICreateCollectionOp,
+  IDropCollectionOp,
+  IAddFieldOp,
+  ICreateIndexOp,
+} from '../lib/db-types.js';
+
+interface SchemaGenerateOpts {
+  db?: string;
+  destructive?: boolean;
+}
+
+interface ReconstructedTable {
+  fields: Set<string>;
+}
+
+function replayMigrations(migrations: IMigration[]): Map<string, ReconstructedTable> {
+  const schema = new Map<string, ReconstructedTable>();
+  for (const migration of migrations) {
+    for (const op of migration.up) {
+      if (op.type === 'createCollection') {
+        if (!schema.has(op.name)) {
+          schema.set(op.name, { fields: new Set(op.fields.map((f) => f.name)) });
+        }
+      } else if (op.type === 'dropCollection') {
+        schema.delete(op.name);
+      } else if (op.type === 'addField') {
+        const t = schema.get(op.collection);
+        if (t) t.fields.add(op.field.name);
+      } else if (op.type === 'dropField') {
+        const t = schema.get(op.collection);
+        if (t) t.fields.delete(op.fieldName);
+      }
+    }
+  }
+  return schema;
+}
+
+export async function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<void> {
+  const found = findProjectConfig();
+  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
+
+  const { dir } = found;
+  const schemaEntries = loadSchemaFile(dir);
+  const targets = opts.db
+    ? schemaEntries.filter((e) => e.db === opts.db)
+    : schemaEntries;
+
+  if (targets.length === 0) {
+    fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
+  }
+
+  let totalGenerated = 0;
+
+  for (const entry of targets) {
+    const { db, tables } = entry;
+    const existing = loadMigrationFiles(dir, db);
+    const current = replayMigrations(existing);
+    const newMigrations: IMigration[] = [];
+    let counter = existing.length + 1;
+
+    for (const [tableName, fieldDefs] of Object.entries(tables)) {
+      const parsed = parseTableDef(tableName, fieldDefs);
+      const currentTable = current.get(tableName);
+
+      if (!currentTable) {
+        const up: IMigrationOperation[] = [
+          {
+            type: 'createCollection',
+            name: tableName,
+            fields: parsed.fields,
+            ifNotExists: true,
+          } as ICreateCollectionOp,
+        ];
+        for (const { fieldName, unique } of parsed.indexFields) {
+          up.push({
+            type: 'createIndex',
+            collection: tableName,
+            name: `${tableName}_${fieldName}_idx`,
+            fields: [{ name: fieldName }],
+            unique,
+            ifNotExists: true,
+          } as ICreateIndexOp);
+        }
+        const down: IMigrationOperation[] = [
+          { type: 'dropCollection', name: tableName, ifExists: true } as IDropCollectionOp,
+        ];
+
+        newMigrations.push({
+          tag: `create_${tableName}`,
+          name: `Create collection ${tableName}`,
+          up,
+          down,
+          createdAt: new Date().toISOString(),
+        });
+      } else {
+        const addOps: IMigrationOperation[] = [];
+        const dropOps: IMigrationOperation[] = [];
+
+        for (const field of parsed.fields) {
+          if (!currentTable.fields.has(field.name)) {
+            addOps.push({ type: 'addField', collection: tableName, field } as IAddFieldOp);
+          }
+        }
+
+        const desiredFields = new Set(parsed.fields.map((f) => f.name));
+        const removedFields: string[] = [];
+        for (const existingField of currentTable.fields) {
+          if (!desiredFields.has(existingField)) {
+            removedFields.push(existingField);
+            if (opts.destructive) {
+              dropOps.push({ type: 'dropField', collection: tableName, fieldName: existingField });
+            }
+          }
+        }
+        if (!opts.destructive && removedFields.length > 0) {
+          console.warn(
+            `  [${db}] Warning: field(s) removed from schema.json for "${tableName}": ${removedFields.join(', ')}. Pass --destructive to generate drop migrations.`,
+          );
+        }
+
+        const allOps = [...addOps, ...dropOps];
+        if (allOps.length > 0) {
+          const down: IMigrationOperation[] = addOps.map((op) => ({
+            type: 'dropField' as const,
+            collection: tableName,
+            fieldName: (op as IAddFieldOp).field.name,
+          }));
+
+          newMigrations.push({
+            tag: `alter_${tableName}_${Date.now()}`,
+            name: `Alter collection ${tableName}`,
+            up: allOps,
+            down,
+            createdAt: new Date().toISOString(),
+          });
+        }
+      }
+    }
+
+    if (newMigrations.length === 0) {
+      console.log(`[${db}] Schema is up to date. No migrations generated.`);
+      continue;
+    }
+
+    for (const migration of newMigrations) {
+      const filePath = writeMigrationFile(dir, db, migration, counter++);
+      console.log(`[${db}] Generated ${path.basename(filePath)}`);
+      totalGenerated++;
+    }
+  }
+
+  if (totalGenerated > 0) {
+    console.log(`\nGenerated ${totalGenerated} migration file(s). Run \`ductape db migrate\` to apply them.`);
+  }
+}

package/src/commands/install.ts

@@ -1,15 +1,42 @@
-import { spawnSync } from 'node:child_process';
+import { spawnSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { resolvePlatformDir } from '../lib/config.js';
+import { fileURLToPath } from 'node:url';
+import { HUB_PLATFORM_DIR } from '../lib/config.js';
 import { success } from '../lib/output.js';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.resolve(__dirname, '../../templates');
+
+const HUB_IMAGES = [
+  'ductape/platform-api:latest',
+  'ductape/platform-workbench:latest',
+] as const;
+
 function checkCommand(cmd: string, args: string[]): boolean {
   const r = spawnSync(cmd, args, { stdio: 'ignore' });
   return r.status === 0;
 }
 
-export function runInstall(): void {
+function pull(image: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    console.log(`Pulling ${image} …`);
+    const child = spawn('docker', ['pull', image], {
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+    child.on('error', reject);
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+function copyTemplate(name: string, dest: string, overwrite = false): void {
+  const src = path.join(TEMPLATES_DIR, name);
+  if (!overwrite && fs.existsSync(dest)) return;
+  fs.copyFileSync(src, dest);
+}
+
+export async function runInstall(): Promise<void> {
   const issues: string[] = [];
 
   if (!checkCommand('docker', ['--version'])) {
@@ -18,31 +45,32 @@ export function runInstall(): void {
     issues.push('Docker Compose v2 is required (docker compose)');
   }
 
-  if (!checkCommand('node', ['--version'])) {
-    issues.push('Node.js 18+ is recommended for running the CLI');
-  }
-
-  let platformDir: string;
-  try {
-    platformDir = resolvePlatformDir();
-  } catch (e) {
-    issues.push(e instanceof Error ? e.message : String(e));
-    platformDir = '';
+  if (issues.length > 0) {
+    console.error('Install check failed:\n' + issues.map((i) => `  - ${i}`).join('\n'));
+    process.exit(1);
   }
 
-  if (platformDir) {
-    const envExample = path.join(platformDir, '.env.example');
-    const envFile = path.join(platformDir, '.env');
-    if (fs.existsSync(envExample) && !fs.existsSync(envFile)) {
-      fs.copyFileSync(envExample, envFile);
-      success(`Created ${envFile} from .env.example`);
+  // Pull platform images from Docker Hub
+  for (const image of HUB_IMAGES) {
+    const code = await pull(image);
+    if (code !== 0) {
+      console.error(`Failed to pull ${image} (exit ${code}). Check your internet connection or run \`docker login\`.`);
+      process.exit(1);
     }
   }
 
-  if (issues.length > 0) {
-    console.error('Install check failed:\n' + issues.map((i) => `  - ${i}`).join('\n'));
-    process.exit(1);
-  }
+  // Write platform files to ~/.ductape/platform/
+  fs.mkdirSync(HUB_PLATFORM_DIR, { recursive: true });
+
+  copyTemplate('docker-compose.release.yml', path.join(HUB_PLATFORM_DIR, 'docker-compose.yml'), true);
+  copyTemplate('api-gateway.conf', path.join(HUB_PLATFORM_DIR, 'api-gateway.conf'), true);
+  copyTemplate('platform.env', path.join(HUB_PLATFORM_DIR, '.env'), false); // don't overwrite existing .env
 
-  success('Prerequisites OK. Run `ductape start` to launch the local platform.');
+  success(`Platform installed to ${HUB_PLATFORM_DIR}`);
+  console.log('');
+  console.log('  Edit ~/.ductape/platform/.env to add your AWS credentials (needed for cloud connections).');
+  console.log('  Then run:  ductape start');
+  console.log('');
+  console.log('  Workbench:  http://localhost:4310');
+  console.log('  API:        http://localhost:4311');
 }