midsummer-sol 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midsummer-sol",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Sol — agent-native version control (a new git). CLI, MCP server, and no-filesystem SDK.",
   "bin": {
     "sol": "./sol.js",

package/sol.js

@@ -885,7 +885,6 @@ import {
   readdirSync as readdirSync3,
   readFileSync as readFileSync3,
   readlinkSync,
-  rmdirSync,
   symlinkSync,
   unlinkSync,
   writeFileSync as writeFileSync3
@@ -1403,7 +1402,6 @@ import {
   readdirSync as readdirSync5,
   readFileSync as readFileSync6,
   readlinkSync as readlinkSync3,
-  rmdirSync as rmdirSync2,
   symlinkSync as symlinkSync3,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync6
@@ -1581,20 +1579,42 @@ async function snapshotTree(repo) {
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+var LOCK_STALE_MS = 5000;
+function pidAlive(pid) {
+  if (!pid || pid < 1)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
 function acquireLock() {
-  const lockDir = join6(solDir2, "lock");
+  const lockFile = join6(solDir2, "lock");
   const deadline = Date.now() + 15000;
   for (;; ) {
     try {
-      mkdirSync5(lockDir);
+      writeFileSync6(lockFile, String(process.pid), { flag: "wx" });
       break;
     } catch {
       try {
-        if (Date.now() - lstatSync3(lockDir).mtimeMs > 30000) {
-          rmdirSync2(lockDir);
-          continue;
+        const st = lstatSync3(lockFile);
+        if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
+          let ownerPid = 0;
+          try {
+            ownerPid = parseInt(readFileSync6(lockFile, "utf8").trim(), 10) || 0;
+          } catch {}
+          if (!pidAlive(ownerPid)) {
+            try {
+              unlinkSync4(lockFile);
+            } catch {}
+            continue;
+          }
         }
-      } catch {}
+      } catch {
+        continue;
+      }
       if (Date.now() > deadline)
         die("repo is locked by another sol process (timed out)");
       sleepSync(25);
@@ -1606,7 +1626,7 @@ function acquireLock() {
       return;
     released = true;
     try {
-      rmdirSync2(lockDir);
+      unlinkSync4(lockFile);
     } catch {}
   };
   process.on("exit", release);
@@ -2570,12 +2590,15 @@ async function main() {
   const args = argv.slice(1);
   const wantsHelp = args.includes("--help") || args.includes("-h");
   const SUBHELP = {
-    commit: `sol commit "<message>"            commit the whole working tree (single author)
-  sol commit -m "<message>" <file>...   commit ONLY those paths (correct attribution for concurrent agents)
+    commit: `sol commit "<msg>"                commits the whole working tree; works as-is for a solo author.
+  sol commit -m "<msg>" <file>...   commit ONLY those paths (correct attribution for concurrent agents)
+
+  (once OTHER authors have committed to this repo, a whole-tree commit is refused to avoid mis-attribution
+  \u2014 scope to files \`sol commit -m "<msg>" <files>\` or force with --whole-tree).
 
 flags:
   -m <message>        message when scoping to files
-  --whole-tree        allow a whole-tree commit even with SOL_ACTOR set (else refused)
+  --whole-tree        force a whole-tree commit even after OTHER authors are present (the guard above)
   --force             commit even with unresolved <<<<<<< conflict markers
 
 examples:
@@ -2584,14 +2607,21 @@ examples:
     push: `sol push                          push the current branch to the configured remote (converging \u2014 never FF-rejected)
   sol push <repo>                   if no remote is set, use the hosted Sol (${DEFAULT_REMOTE_URL}) + this repo name, then push
   sol push --create <repo>          same, explicit form (creates the repo on first push)
+  sol push --public <repo>          create + push + make it public in ONE step (else new repos are private)
+
+flags:
+  --create            explicit "creates the repo on first push" (the bare \`<repo>\` form does this too)
+  --public            after a successful create/push, set public access (same op as \`sol access public\`)
 
 notes:
   a remote already configured? the <repo>/--create arg is ignored \u2014 \`sol push\` just syncs.
+  new repos are PRIVATE by default; \`--public\` is the one-step opt-in to share (or \`sol access public\` later).
   set SOL_TOKEN (or \`sol auth login\`) first; the push registers the current branch's head on the remote.
 
 examples:
   sol push                          # remote already configured
-  sol push alice/app                # one step: configure hosted remote + push`,
+  sol push alice/app                # one step: configure hosted remote + push (private)
+  sol push --create --public alice/app   # create + push + share, all at once`,
     pull: `sol pull                          fetch + converge the current branch from the configured remote
   sol pull <dir>                    OFFLINE: converge another local repo's .sol on disk into this one (multi-agent, no network)
 
@@ -2634,7 +2664,8 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
   sol mr comment <id> -m msg [--path f --line N] | check <id> --run -- <cmd> | merge <id> [--force] | close <id>`,
     fork: "sol fork [<url>] <parent-repo> <new-repo> [dir]   \u2014 your own copy (all branches + history + a parent link)",
     forks: "sol forks   \u2014 list the forks of the current repo",
-    access: "sol access [show | public | private | add <userId> <read|write|admin> | remove <userId>]",
+    access: "sol access [show | public | private | add <userId> <read|write|admin> | remove <userId>]\n  tip: to share a NEW repo in one step, `sol push --public <repo>` (create + push + public) instead of pushing then `sol access public`.",
+    share: "sol share   \u2014 there is no separate share command: a new repo goes public in one step with `sol push --public <repo>`,\n  or flip an existing one with `sol access public`. (new repos are private by default.)",
     auth: "sol auth [login [<web-url>] | logout | status | whoami | set-handle <name> | pat [days]]",
     clone: "sol clone [<url>] <owner>/<repo> [dir]   \u2014 default dir = <repo> (url defaults to the hosted Sol)"
   };
@@ -2648,7 +2679,7 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
     if (t)
       process.env.SOL_TOKEN = t;
   }
-  const release = new Set(["add", "track", "commit", "checkpoint", "rm", "gc", "branch", "tag", "switch", "merge", "pull", "run", "seal"]).has(cmd) && existsSync10(solDir2) ? acquireLock() : undefined;
+  const release = new Set(["add", "track", "commit", "checkpoint", "rm", "gc", "branch", "tag", "switch", "merge", "pull", "push", "restore", "checkout", "run", "seal"]).has(cmd) && existsSync10(solDir2) ? acquireLock() : undefined;
   try {
     switch (cmd) {
       case "init": {
@@ -2727,10 +2758,12 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
           commitRoot = await repo.head();
         } else {
           const optedIn = wholeTreeOptIn || process.env.SOL_ALLOW_WHOLE_TREE === "1";
-          const otherActorPresent = (await log.history()).some((o) => o.by && o.by !== actor2);
+          const otherActors = [...new Set((await log.history()).map((o) => o.by).filter((b) => !!b && b !== actor2))];
+          const otherActorPresent = otherActors.length > 0;
           if (process.env.SOL_ACTOR && !optedIn && otherActorPresent) {
-            die(`refusing a whole-tree commit as "${actor2}" \u2014 it would attribute ALL pending files to you.
-  concurrent agents: sol commit -m "${message}" <your files>   (or a per-agent SolWorkspace/MCP)
+            const others = otherActors.join(", ");
+            die(`refusing a whole-tree commit as "${actor2}" \u2014 other author(s) have committed here (${others}), so sweeping the whole tree would mis-attribute their pending files to you. (this guard only fires because they're present; a solo author commits the whole tree freely.)
+  scope to your files: sol commit -m "${message}" <your files>   (or a per-agent SolWorkspace/MCP)
   if you truly own the whole tree: add --whole-tree  or set SOL_ALLOW_WHOLE_TREE=1`);
           }
           const snap = await snapshotTree(repo);
@@ -2767,8 +2800,11 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
         const { repo, log } = open();
         const refs = existsSync10(refsPath()) ? await loadRefs(log) : undefined;
         const head = await repo.head();
+        const headOp = head ? [...await log.history()].reverse().find((o) => o.rootAfter === head) : undefined;
+        const headBy = headOp?.by ?? "?";
         console.log(`repo ${cwd2}`);
-        console.log(`on ${refs ? refs.current : "main"}   head ${head.slice(0, 14)}   seq ${await log.seq()}   actor ${actor2}`);
+        console.log(`on ${refs ? refs.current : "main"}   head ${head ? `${head.slice(0, 14)} by ${headBy}` : "(empty)"}   seq ${await log.seq()}`);
+        console.log(`you: ${actor2}`);
         const ch = workingChanges(loadStore(), head);
         const dirty = ch.added.length + ch.modified.length + ch.removed.length;
         if (!dirty) {
@@ -3407,9 +3443,9 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
       }
       case "push": {
         const { log } = open();
+        const wantPublic = args.includes("--public");
         if (!loadRemote(solDir2)) {
-          const ci = args.indexOf("--create");
-          const repoName = ci >= 0 ? args[ci + 1] : args.find((a) => !a.startsWith("-"));
+          const repoName = args.find((a) => !a.startsWith("-"));
           if (repoName) {
             saveRemote(solDir2, { url: DEFAULT_REMOTE_URL, repo: repoName });
             console.log(`remote set: ${DEFAULT_REMOTE_URL} (repo ${repoName})`);
@@ -3468,6 +3504,10 @@ tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
         } else {
           console.log(`pushed ${res.applied} op(s) -> remote (branch ${branch} @ ${(convergedHead || "").slice(0, 12)})${mergedNote}${conflictNote}${prod ? `; production=${prod}` : ""}`);
         }
+        if (wantPublic) {
+          const a = await accessSet(cfg, token, { visibility: "public" });
+          console.log(`${cfg.repo} is now ${a.visibility}`);
+        }
         break;
       }
       case "pull": {
@@ -4056,6 +4096,7 @@ remotes (self-hostable backend; token in SOL_TOKEN or via sol auth login):
   sol clone [<url>] <owner>/<repo> [dir]   clone a remote repo (checks out PRODUCTION); default dir = <repo>
   sol push / sol pull          sync your commits with the remote (push registers your branch's head)
   sol push <repo>                one-step share: no remote set? use the hosted Sol + <repo>, then push
+  sol push --public <repo>       create + push + make public in one step (new repos are private by default)
   sol promote [branch]         point the remote's production branch at <branch> (default: current)
   sol remote <url> <repo>        set the remote (no arg: show it; url defaults to the hosted Sol)
   sol fork [<url>] <parent> <new> [dir]   make your own copy of a repo (all branches + history + a parent link)
@@ -4076,7 +4117,8 @@ git interop (adopt Sol without leaving GitHub):
   sol git export <repo>          write Sol's tree back as a git commit (+ deletes), then \`git push\`
 
 for concurrent agents, use scoped commits (sol commit -m "msg" file) or a per-agent workspace.
-a whole-tree commit is REFUSED when SOL_ACTOR is set (--whole-tree / SOL_ALLOW_WHOLE_TREE=1 to override).
+a solo author commits the whole tree freely; once OTHER authors are present the whole-tree commit is refused
+(--whole-tree / SOL_ALLOW_WHOLE_TREE=1 to override) so one agent can't sweep everyone's pending files.
 
 a ref is a branch/tag name, a commit hash-prefix, an op seq number, or HEAD. content is SHA-256
 addressed; history is a tamper-evident hash-chained op-log. attribute changes with SOL_ACTOR=you.`);