@motionode/cli 0.1.0 → 0.1.2

package/README.md

@@ -20,5 +20,5 @@ motionode finish T11-518   # Motionode checks your pushed commits and moves the
 - It runs only fixed git operations Motionode can ask for (check out a ticket
   branch, show a diff, commit and push, move changes onto a ticket branch) —
   never arbitrary commands.
-- `--api URL` (or `MOTIONODE_API_URL`) points it at another Motionode API.
+- `motionode use <url>` points every terminal at another Motionode API until `motionode use production`; `--api URL` or `MOTIONODE_API_URL` overrides it for one run. `motionode where` shows the current one.
 - Revoke a computer in Motionode → Settings → Development workflow.

package/bin/motionode.js

@@ -15,9 +15,13 @@ const HELP = `motionode ${version} — work Motionode tickets with your own loca
   motionode work <ticket>                       start a ticket locally and check out its branches (e.g. T11-518)
   motionode finish <ticket> [--force] [--note]  you're done: Motionode checks your pushed commits and moves it on
   motionode status                              what each linked folder has checked out and changed
+  motionode where                               which Motionode this terminal talks to
+  motionode use <url|production>                switch which Motionode the CLI talks to (remembered)
   motionode logout                              disconnect this computer
 
-Git stays yours: fetch, commit and push use your own git credentials and identity.`;
+Git stays yours: fetch, commit and push use your own git credentials and identity.
+Talks to production (https://api.motionode.com) unless "motionode use", MOTIONODE_API_URL or --api says otherwise;
+each Motionode keeps its own connection.`;
 
 function flags(argv) {
 	const out = { _: [] };
@@ -37,8 +41,8 @@ function flags(argv) {
 async function main() {
 	const [command, ...rest] = process.argv.slice(2);
 	const args = flags(rest);
-	const config = Config.load();
-	if (args.api) config.apiUrl = String(args.api).replace(/\/+$/, '');
+	// --api (or MOTIONODE_API_URL) picks the Motionode — and its own saved connection.
+	const config = Config.load(typeof args.api === 'string' ? args.api : null);
 	switch (command) {
 		case 'connect':
 			return Commands.connect(config, { apiUrl: args.api || null, name: args.name || null, service: args.service || null, relogin: !!args.relogin });
@@ -56,6 +60,15 @@ async function main() {
 			return Commands.finish(config, args._[0], { force: !!args.force, note: typeof args.note === 'string' ? args.note : null });
 		case 'status':
 			return Commands.status(config);
+		case 'use': {
+			const api = Config.useApi(args._[0]);
+			const next = Config.load();
+			console.log(`✓ Using ${api}${next.token ? '' : ' — run "motionode connect" in a repository folder to connect this computer to it'}`);
+			return null;
+		}
+		case 'where':
+			console.log(`${config.apiUrl}${config.token ? ` — connected as ${config.user?.name || config.user?.email || 'you'} (${config.machine?.name || 'this computer'})` : ' — not connected'}`);
+			return null;
 		case 'logout':
 			return Commands.logout(config);
 		case '--version':

package/lib/commands.js

@@ -21,8 +21,8 @@ function openBrowser(url) {
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /** Device-code login: approve this computer in the browser once. */
-async function login(config, { apiUrl = null, name = null } = {}) {
-	if (apiUrl) config.apiUrl = apiUrl.replace(/\/+$/, '');
+async function login(config, { name = null } = {}) {
+	// config.apiUrl was already chosen (--api / MOTIONODE_API_URL / production).
 	const api = client({ ...config, token: null });
 	const machineName = name || os.hostname();
 	const start = await api.post('/device/start', { machineName, platform: `${process.platform}-${process.arch}` });

package/lib/config.js

@@ -1,9 +1,13 @@
 'use strict';
 
 /**
- * ~/.motionode/config.json — the machine token, the API it talks to, and which
- * local folders are which Motionode repositories. Folder paths never leave this
+ * ~/.motionode/ — the machine token, the API it talks to, and which local
+ * folders are which Motionode repositories. Folder paths never leave this
  * machine except as the label shown to their owner in Motionode.
+ *
+ * One connection per Motionode: production lives in config.json; any other API
+ * (MOTIONODE_API_URL or --api, e.g. a local API behind a tunnel) gets its own
+ * config.<host>.json, so switching between them never disconnects the other.
  */
 
 const fs = require('fs');
@@ -11,27 +15,67 @@ const os = require('os');
 const path = require('path');
 
 const DIR = process.env.MOTIONODE_HOME || path.join(os.homedir(), '.motionode');
-const FILE = path.join(DIR, 'config.json');
-const DEFAULT_API = process.env.MOTIONODE_API_URL || 'https://api.motionode.com';
+const PRODUCTION_API = 'https://api.motionode.com';
 
-function load() {
+function normalizeApi(url) {
+	return String(url || '').trim().replace(/\/+$/, '') || null;
+}
+
+const CURRENT_FILE = path.join(DIR, 'current.json');
+
+/** The Motionode chosen with `motionode use` (stays until changed). */
+function savedApi() {
+	try {
+		return normalizeApi(JSON.parse(fs.readFileSync(CURRENT_FILE, 'utf8')).apiUrl);
+	} catch (_e) {
+		return null;
+	}
+}
+
+/** `motionode use <url|production>` — which Motionode every terminal talks to. */
+function useApi(url) {
+	const next = String(url || '').trim().toLowerCase() === 'production' ? PRODUCTION_API : normalizeApi(url);
+	if (!next || !/^https?:\/\//.test(next)) throw new Error('Give a Motionode API address (https://…) or "production".');
+	fs.mkdirSync(DIR, { recursive: true });
+	if (next === PRODUCTION_API) {
+		try { fs.unlinkSync(CURRENT_FILE); } catch (_e) { /* already production */ }
+	} else {
+		fs.writeFileSync(CURRENT_FILE, JSON.stringify({ apiUrl: next }, null, 2));
+	}
+	return next;
+}
+
+/** The API this run talks to: --api, then MOTIONODE_API_URL, then `motionode use`, then production. */
+function resolveApi(override = null) {
+	return normalizeApi(override) || normalizeApi(process.env.MOTIONODE_API_URL) || savedApi() || PRODUCTION_API;
+}
+
+function fileFor(apiUrl) {
+	if (normalizeApi(apiUrl) === PRODUCTION_API) return path.join(DIR, 'config.json');
+	let host = 'custom';
+	try { host = new URL(apiUrl).host; } catch (_e) { /* keep "custom" */ }
+	return path.join(DIR, `config.${host.replace(/[^a-zA-Z0-9.-]/g, '_')}.json`);
+}
+
+function load(apiOverride = null) {
+	const apiUrl = resolveApi(apiOverride);
 	try {
-		const raw = JSON.parse(fs.readFileSync(FILE, 'utf8'));
+		const raw = JSON.parse(fs.readFileSync(fileFor(apiUrl), 'utf8'));
 		return {
-			apiUrl: raw.apiUrl || DEFAULT_API,
+			apiUrl,
 			token: raw.token || null,
 			machine: raw.machine || null,
 			user: raw.user || null,
 			workspaces: Array.isArray(raw.workspaces) ? raw.workspaces : [],
 		};
 	} catch (_e) {
-		return { apiUrl: DEFAULT_API, token: null, machine: null, user: null, workspaces: [] };
+		return { apiUrl, token: null, machine: null, user: null, workspaces: [] };
 	}
 }
 
 function save(config) {
 	fs.mkdirSync(DIR, { recursive: true });
-	fs.writeFileSync(FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+	fs.writeFileSync(fileFor(config.apiUrl), JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
 function samePath(a, b) {
@@ -43,4 +87,4 @@ function workspaceForPath(config, dir) {
 	return (config.workspaces || []).find((w) => samePath(w.path, dir)) || null;
 }
 
-module.exports = { DIR, FILE, DEFAULT_API, load, save, samePath, workspaceForPath };
+module.exports = { DIR, PRODUCTION_API, resolveApi, useApi, fileFor, load, save, samePath, workspaceForPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motionode/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Connect your local repositories to Motionode: work tickets in Cursor, VS Code or any editor while Motionode keeps the work tied to the ticket, its git branches, verification and delivery.",
   "license": "UNLICENSED",
   "bin": {