directionallylocal 0.8.0 → 0.8.1

package/README.md

@@ -11,7 +11,7 @@ dl
 
 `dl` asks where your agents should run:
 
-- **On this computer** — start now, nothing to rent, pauses when this computer sleeps.
+- **On this computer** — start now, nothing to rent, pauses when this computer sleeps. macOS and Linux; not offered on Windows yet (connect a server, or run `dl` inside WSL 2, which takes the Linux path).
 - **On my own server** — keeps going when your laptop is closed; needs SSH access.
 
 For a server, `dl` lists the hosts in `~/.ssh/config` (or takes `user@host[:port]`), checks it over SSH, installs itself there, and pairs this laptop. Nothing is exposed on the server: `dl` reaches it through an SSH tunnel.

package/dist/laptop/session.js

@@ -55,7 +55,7 @@ export async function projectSession(input, io) {
         note(describeError(error));
         return undefined;
     }
-    const { remote } = target;
+    const { remote, reason } = target;
     const key = { place: remote.name, repository, root };
     const file = input.sessionsFile ?? sessionsPath();
     const autopilot = await (input.autopilot ?? findAutopilot)();
@@ -142,7 +142,12 @@ export async function projectSession(input, io) {
                 // `dl new`: the old conversation keeps running on the place (dl runs lists it).
                 if (input.fresh)
                     await forgetSession(key, file);
-                io.err(`\n  ${c.cyan("·")} Connecting to ${c.bold(remote.name)} · ${repository} …  ${c.dim(`(${detail})`)}\n`);
+                // The place is on the Connecting line already; with more than one set up, also why this
+                // one and how to pick another, as `dl run` does (a place named with --server needs neither).
+                const chosen = reason === "default" || reason === "last used";
+                io.err(`\n  ${c.cyan("·")} Connecting to ${c.bold(remote.name)}${chosen ? ` ${c.dim(`(${reason})`)}` : ""} · ${repository} …  ${c.dim(`(${detail})`)}\n`);
+                if (chosen)
+                    io.err(`    ${c.dim("dl use NAME to change where dl runs")}\n`);
                 // The token goes in the environment only: argv is visible to every user on the machine.
                 const env = { ...process.env, AUTOPILOT_REMOTE_URL: client.baseUrl, AUTOPILOT_REMOTE_TOKEN: remote.token };
                 let saved = remembered?.conversationId;

package/dist/laptop/settings.js

@@ -37,7 +37,10 @@ export async function loadSettings(path = settingsPath()) {
     }
     try {
         const parsed = JSON.parse(raw);
-        return typeof parsed.model === "string" && parsed.model.trim() ? { model: parsed.model.trim() } : {};
+        return {
+            ...(typeof parsed.model === "string" && parsed.model.trim() ? { model: parsed.model.trim() } : {}),
+            ...(parsed.askedLocalDefault === true ? { askedLocalDefault: true } : {}),
+        };
     }
     catch {
         // A damaged file only loses the saved model; the next save rewrites it.
@@ -45,7 +48,11 @@ export async function loadSettings(path = settingsPath()) {
     }
 }
 export async function saveModel(model, path = settingsPath()) {
-    const settings = { ...(await loadSettings(path)), model };
+    await saveSettings({ model }, path);
+}
+/** Merges into dl's settings, keeping what's already there. */
+export async function saveSettings(changes, path = settingsPath()) {
+    const settings = { ...(await loadSettings(path)), ...changes };
     await mkdir(dirname(path), { recursive: true });
     const temp = `${path}.${process.pid}.tmp`;
     await writeFile(temp, `${JSON.stringify({ version: 1, ...settings }, null, 2)}\n`, { mode: 0o600 });

package/dist/laptop/setup.js

@@ -5,11 +5,12 @@ import { join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { PromptCancelled, TtyPrompter } from "../prompt.js";
 import { palette, PlainUi, TerminalUi } from "../ui.js";
-import { loadRemotes, loadRemotesFile, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote, setDefaultRemote } from "./config.js";
+import { localUnsupported } from "../local/check.js";
+import { loadRemotes, loadRemotesFile, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, resolveTarget, saveRemote, setDefaultRemote } from "./config.js";
 import { confirm, gatherKeys } from "./credentials.js";
 import { bootstrap, INSTALL_URL, installOnServer, pairLaptop, serverNeeds } from "./remote-install.js";
 import { checkServer, describeHost, discoverKeys, hostOf, parseSshConfig, parseTarget, realSshExec, SshAuthError } from "./ssh.js";
-import { askModel, DEFAULT_MODEL, loadSettings, modelPrices, readAutopilotModel, saveModel } from "./settings.js";
+import { askModel, DEFAULT_MODEL, loadSettings, modelPrices, readAutopilotModel, saveModel, saveSettings } from "./settings.js";
 import { openRemote, withConnections } from "./tunnel.js";
 const RUN_EXAMPLE = 'dl run "fix the flaky checkout test"';
 const PLACES = [
@@ -20,6 +21,13 @@ export async function setupWizard(deps) {
     const c = palette(deps.color);
     deps.write(`\n  ${c.bold("Directionally Local")}\n  Background coding agents. Where should they run?\n\n`);
     const ui = deps.newUi();
+    // Where this computer can't run agents (Windows), the list would hold one real choice: say why, and go on.
+    const unsupported = localUnsupported(deps.platform ?? process.platform);
+    if (unsupported) {
+        ui.line("info", "On this computer", unsupported);
+        ui.answered("Where", "On my own server");
+        return setUpServer(deps);
+    }
     let where = (await deps.prompter.select(ui.prompt("Where"), PLACES, 0)).value;
     ui.answered("Where", where === "local" ? "On this computer" : "On my own server");
     if (where === "local" && !deps.localSetup) {
@@ -39,8 +47,7 @@ export async function setupWizard(deps) {
         const remotesFile = deps.remotesFile ?? remotesPath();
         const isNew = !(await loadRemotes(remotesFile)).some((entry) => entry.name === remote.name);
         await saveRemote(remote, remotesFile);
-        if (isNew)
-            await chooseDefault(deps, remote, remotesFile);
+        await offerThisComputer(deps, remote, remotesFile, isNew);
         await chooseModel(deps);
         finishScreen(deps.newUi(), capacity);
         return remote;
@@ -142,7 +149,7 @@ async function chooseServer(deps, hosts) {
 }
 /**
  * With two or more places set up, where `dl run` sends tasks unless told otherwise. Asked
- * only when setup adds a place, with the new one preselected; the first place becomes the
+ * only when setup adds a server, with the new one preselected (this computer: offerThisComputer); the first place becomes the
  * default by itself (saveRemote).
  */
 async function chooseDefault(deps, added, remotesFile) {
@@ -158,6 +165,36 @@ async function chooseDefault(deps, added, remotesFile) {
     ui.answered("Default", value);
     ui.finish();
 }
+/**
+ * After "on this computer", when commands would still go somewhere else (a server set up
+ * first stays the default, saveRemote): asks once, at a terminal, whether this computer
+ * should be the default instead. Asked again only when this computer is newly added.
+ * Otherwise (no terminal, already asked, or "no") it says where things go and how to change it.
+ */
+async function offerThisComputer(deps, local, remotesFile, isNew) {
+    const { remotes } = await loadRemotesFile(remotesFile);
+    if (remotes.length < 2)
+        return;
+    const current = await resolveTarget(undefined, remotesFile).then((target) => target.remote.name, () => undefined);
+    if (current === local.name)
+        return;
+    const hint = `dl use ${local.name}`;
+    const ui = deps.newUi();
+    deps.write("\n");
+    if (deps.interactive !== false && (isNew || !(await loadSettings(deps.settingsFile)).askedLocalDefault)) {
+        const question = current ? `Make this computer the default? Tasks and sessions go to ${current} now` : "Make this computer the default for tasks and sessions?";
+        const yes = await confirm(ui, deps.prompter, question);
+        await saveSettings({ askedLocalDefault: true }, deps.settingsFile);
+        if (yes) {
+            await setDefaultRemote(local.name, remotesFile);
+            ui.answered("Default", "this computer");
+            ui.finish();
+            return;
+        }
+    }
+    ui.line("info", "Default", current ? `still ${current} · ${hint} to run here instead` : `none yet · ${hint} to run here`);
+    ui.finish();
+}
 /**
  * Which model tasks and sessions use, asked once: setup skips it when dl already has one
  * (dl model changes it). Autopilot's own default is preselected for people who have one.
@@ -335,6 +372,7 @@ export async function setup(options) {
             installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
             ...(options.localSetup ? { localSetup: options.localSetup } : {}),
             ...(identityFile ? { identityFile } : {}),
+            interactive: terminal && process.stdin.isTTY === true,
         });
     }
     catch (error) {

package/dist/local/check.js

@@ -41,9 +41,9 @@ export async function checkComputer(system, options) {
 /** What stops setup before it changes anything, each with how to fix it. */
 export function computerProblems(facts) {
     const problems = [];
-    if (facts.platform !== "darwin" && facts.platform !== "linux") {
-        return [`Running agents on this computer works on macOS and Linux, not ${facts.platform}. Set up a server instead: curl -fsSL https://directionallylocal.run | sh`];
-    }
+    const unsupported = localUnsupported(facts.platform);
+    if (unsupported)
+        return [unsupported];
     if (facts.platform === "linux" && !facts.systemdUser) {
         problems.push("A systemd user session is needed to keep the agents running (systemctl --user). Log in to a desktop session, or set up a server instead.");
     }
@@ -79,6 +79,20 @@ function dockerFix(facts) {
 export function localCapacity(docker) {
     return agentCapacity({ memoryMb: docker.memoryMb, cpus: docker.cpus }, LOCAL_CELL_MEMORY_MB);
 }
+/**
+ * Why agents can't run on this computer's platform, or undefined on macOS and Linux. The
+ * local setup is POSIX throughout (sh, launchd or systemd --user, unix sockets), so other
+ * platforms are refused before anything runs. WSL reports "linux" and takes the Linux path.
+ */
+export function localUnsupported(platform) {
+    if (supportedPlatform(platform))
+        return undefined;
+    if (platform === "win32") {
+        return "Running on this computer isn't supported on Windows yet; connect a server instead (dl setup, then \"On my own server\"). "
+            + "Inside WSL 2, dl runs as on Linux (it needs systemd and Docker there).";
+    }
+    return `Running agents on this computer works on macOS and Linux, not ${platform}. Connect a server instead: dl setup, then "On my own server".`;
+}
 export function supportedPlatform(platform) {
     return platform === "darwin" || platform === "linux" ? platform : undefined;
 }

package/dist/local/keys.js

@@ -8,7 +8,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { checkKey, githubListing, hotcellKeyListed, KeyRejectedError } from "../keys.js";
 import { RealSystem } from "../system.js";
-import { supportedPlatform } from "./check.js";
+import { localUnsupported, supportedPlatform } from "./check.js";
 import { LOCAL_SERVICES, localGithubEnv, localHotcellBin, localPaths, parseLocalEnvFile, serviceFile } from "./layout.js";
 import { httpStatus } from "./probes.js";
 import { userId } from "./services.js";
@@ -16,9 +16,10 @@ import { hotcellCliEnv } from "./setup.js";
 import { readLocalState } from "./state.js";
 async function installed(options) {
     const home = options.home ?? homedir();
-    const platform = supportedPlatform(options.platform ?? process.platform);
+    const raw = options.platform ?? process.platform;
+    const platform = supportedPlatform(raw);
     if (!platform)
-        throw new Error("Agents run on this computer only on macOS and Linux.");
+        throw new Error(localUnsupported(raw));
     const system = options.system ?? new RealSystem(() => { });
     const paths = localPaths(home, platform);
     const state = await readLocalState(system, paths);

package/dist/local/setup.js

@@ -26,7 +26,7 @@ import { join } from "node:path";
 import { cellDockerfile, cellImage } from "../layout.js";
 import { removeRemote } from "../laptop/config.js";
 import { RealSystem } from "../system.js";
-import { checkComputer, computerProblems, localCapacity, servicePath, supportedPlatform } from "./check.js";
+import { checkComputer, computerProblems, localCapacity, localUnsupported, servicePath, supportedPlatform } from "./check.js";
 import { LOCAL_SERVICES, PAIRED_NAME, PREFERRED_PORTS, autopilotXdg, localAsterConfig, localAutopilotBin, localAutopilotEnv, localGithubEnv, localHotcellBin, localHotcellEnv, localPaths, parseLocalEnvFile, serviceSpecs, } from "./layout.js";
 import { fileMtime, modelPricesHealth, refreshModelPrices } from "../model-prices.js";
 import { httpStatus, portFree } from "./probes.js";
@@ -37,10 +37,16 @@ const SETUP_LOG = "setup.log";
 export function localSetupLog(home = homedir()) {
     return join(home, ".directionallylocal", "logs", SETUP_LOG);
 }
+/** Stops on a platform the local setup can't run on (Windows), before any command runs. */
+export function assertLocalSupported(platform = process.platform) {
+    const unsupported = localUnsupported(platform);
+    if (unsupported)
+        throw new Error(unsupported);
+}
 function context(options, logName) {
     const home = options.home ?? homedir();
     const rawPlatform = options.platform ?? process.platform;
-    // Unsupported platforms still get paths (for a clear refusal); nothing is written there.
+    // Callers refuse unsupported platforms first (assertLocalSupported); this only keeps types simple.
     const platform = supportedPlatform(rawPlatform) ?? "linux";
     return {
         // Other tools' output goes to a log file (or nowhere), never the screen.
@@ -54,12 +60,15 @@ function context(options, logName) {
 }
 /** Checks this computer without changing anything, e.g. before the wizard asks for keys. */
 export async function checkThisComputer(options = {}) {
+    assertLocalSupported(options.platform);
     const ctx = context(options);
     const facts = await checkComputer(ctx.system, checkOptions(ctx, options));
     return { facts, problems: computerProblems(facts) };
 }
 export async function setUpOnThisComputer(input) {
     const { ui } = input;
+    // Before the checklist: on Windows nothing here (sh, launchd/systemd, unix sockets) works.
+    assertLocalSupported(input.platform);
     const ctx = context(input, SETUP_LOG);
     const { system, paths, platform } = ctx;
     const now = () => (input.now ?? (() => new Date()))().toISOString();
@@ -84,9 +93,6 @@ export async function setUpOnThisComputer(input) {
     };
     const { facts, uid } = await step("check", async () => {
         let facts = await checkComputer(system, checkOptions(ctx, input));
-        const unsupported = computerProblems(facts);
-        if (ctx.rawPlatform !== "darwin" && ctx.rawPlatform !== "linux")
-            throw new Error(unsupported[0]);
         const uid = await userId(system);
         if (!facts.docker && facts.dockerApp && platform === "darwin") {
             ui.start("check", `opening ${facts.dockerApp}`);
@@ -231,6 +237,7 @@ export async function setUpOnThisComputer(input) {
  */
 export async function uninstallFromThisComputer(input) {
     const { ui } = input;
+    assertLocalSupported(input.platform);
     const ctx = context(input, "uninstall.log");
     const { system, paths, platform } = ctx;
     const state = await readLocalState(system, paths);
@@ -284,6 +291,7 @@ export async function uninstallFromThisComputer(input) {
 }
 /** `dl local status`: is it running, where, and how much fits. Read-only. */
 export async function localStatus(options = {}) {
+    assertLocalSupported(options.platform);
     const ctx = context(options);
     const { system, paths, platform } = ctx;
     const state = await readLocalState(system, paths);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directionallylocal",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Directionally Local: background coding agents on your own server. One-line server install, and the dl command for your server and laptop.",
   "license": "Apache-2.0",
   "homepage": "https://directionallylocal.com",