jj-octo 0.2.4 → 0.3.1

package/README.md

@@ -56,6 +56,14 @@ bun update --global --latest jj-octo
 
 It uses only GitHub's REST API, so that it works in a [Claude Code](https://claude.com/claude-code) cloud session. There, GitHub is reached through a proxy that allows REST calls for the session's repository and blocks GraphQL, which `gh pr` depends on.
 
+Where git reaches github.com through a proxy that adds the credentials itself, as in a Claude Code cloud session that keeps the token outside the sandbox, have `jj-octo` use that proxy too:
+
+```
+jj config set --repo jj-octo.github-auth git-proxy
+```
+
+`jj-octo` then sends its requests through the `http.proxy` that git uses for `https://github.com`, trusts the certificate authorities in git's `http.sslCAInfo` for it, and sends a placeholder token that the proxy replaces. It reads git's settings on each run, so it follows a proxy that moves to another port. `token`, the default, sends your own token.
+
 ## Development
 
 ```

package/dist/jj-octo.js

@@ -18112,7 +18112,7 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.2.4",
+  version: "0.3.1",
   description: "A jj subcommand for working with GitHub that supports stacking",
   license: "MIT",
   repository: {
@@ -18478,6 +18478,10 @@ var PullRequests = responseOf()(ArraySchema(Struct({
   number: PullRequestNumberSchema,
   title: String4
 })));
+var ClosedPullRequests = responseOf()(ArraySchema(Struct({
+  head: Struct({ sha: String4 }),
+  merged_at: NullOr(String4)
+})));
 var StackedPullRequest = Struct({
   number: PullRequestNumberSchema,
   state: Literals(["closed", "open"])
@@ -18493,24 +18497,21 @@ var MergeRequest = Struct({
 });
 var StartedMerge = responseOf()(MergeRequest);
 var MergeResult = responseOf()(MergeRequest);
-var token = gen2(function* () {
-  const fromEnvironment = yield* option2(Redacted2("GH_TOKEN").pipe(orElse(() => Redacted2("GITHUB_TOKEN"))));
-  if (isSome2(fromEnvironment)) {
-    return fromEnvironment.value;
-  }
-  const spawner = yield* ChildProcessSpawner;
-  const stored = (yield* spawner.string(make14("gh", ["auth", "token"]))).trim();
-  return stored === "" ? yield* fail6("no token") : make19(stored);
-}).pipe(mapError2(() => new GitHubFailed({ message: "no GitHub token: set GH_TOKEN, or run `gh auth login`" })));
-var GitHubLive = (repository) => {
+var GitHubLive = (repository, connection) => {
   const repo = (path) => `/repos/${repository.owner}/${repository.name}${path}`;
   return effect(GitHub, gen2(function* () {
-    const bearer = yield* token;
-    const client = (yield* HttpClient).pipe(mapRequest((request) => request.pipe(prependUrl("https://api.github.com"), acceptJson, bearerToken(bearer), setHeaders({
+    const requestInit = match(connection.proxy, {
+      onNone: () => ({}),
+      onSome: ({ ca, url }) => match(ca, {
+        onNone: () => ({ proxy: url }),
+        onSome: (certificates) => ({ proxy: url, tls: { ca: certificates } })
+      })
+    });
+    const client = (yield* HttpClient).pipe(mapRequest((request) => request.pipe(prependUrl("https://api.github.com"), acceptJson, bearerToken(connection.token), setHeaders({
       "user-agent": "jj-octo",
       "x-github-api-version": "2022-11-28"
     }))));
-    const send = (request) => client.execute(request).pipe(flatMap4((response) => response.status < 400 ? succeed6(response) : response.text.pipe(orElseSucceed2(() => ""), flatMap4((text) => fail6(new GitHubFailed({
+    const send = (request) => client.execute(request).pipe(provideService2(RequestInit, requestInit), flatMap4((response) => response.status < 400 ? succeed6(response) : response.text.pipe(orElseSucceed2(() => ""), flatMap4((text) => fail6(new GitHubFailed({
       message: `${request.method} ${request.url} returned ${response.status}: ${text}`
     }))))), catchTag2("HttpClientError", (error) => fail6(new GitHubFailed({ message: error.message }))));
     const json = (schema) => (request) => send(request).pipe(flatMap4(schemaBodyJson(schema)), catchTags2({
@@ -18524,6 +18525,7 @@ var GitHubLive = (repository) => {
       open: stack.pull_requests.filter(({ state }) => state === "open").map(({ number }) => number)
     }))));
     const mergeRequest = (path) => json(MergeResult)(get4(repo(path)));
+    const fromBranch = (branch, state) => repo(`/pulls?state=${state}&head=${repository.owner}:${encodeURIComponent(branch)}`);
     return {
       addToStack: (stack, pullRequests) => send(post(repo(`/stacks/${stack}/add`)).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(asVoid2),
       createPullRequest: ({ base, body, draft, head, title }) => json(CreatedPullRequest)(post(repo("/pulls")).pipe(bodyOf({ base, body, draft, head, title }))).pipe(map7(({ number }) => number)),
@@ -18552,7 +18554,8 @@ var GitHubLive = (repository) => {
           message: `merging #${pullRequest} ended ${settled.status}: ${settled.details.message}`
         });
       }),
-      openPullRequest: (branch) => json(PullRequests)(get4(repo(`/pulls?state=open&head=${repository.owner}:${encodeURIComponent(branch)}`))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
+      mergedHeads: (branch) => json(ClosedPullRequests)(get4(fromBranch(branch, "closed"))).pipe(map7((closed) => closed.filter(({ merged_at }) => merged_at !== null).map(({ head }) => head.sha))),
+      openPullRequest: (branch) => json(PullRequests)(get4(fromBranch(branch, "open"))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
         base: base.ref,
         body: body ?? "",
         draft: draft ?? false,
@@ -18567,6 +18570,60 @@ var GitHubLive = (repository) => {
   }));
 };
 
+// src/clients/github/connection.ts
+var authKey = "jj-octo.github-auth";
+var ownToken = gen2(function* () {
+  const fromEnvironment = yield* option2(Redacted2("GH_TOKEN").pipe(orElse(() => Redacted2("GITHUB_TOKEN"))));
+  if (isSome2(fromEnvironment)) {
+    return fromEnvironment.value;
+  }
+  const spawner = yield* ChildProcessSpawner;
+  const stored = (yield* spawner.string(make14("gh", ["auth", "token"]))).trim();
+  return stored === "" ? yield* fail6("no token") : make19(stored);
+}).pipe(mapError2(() => new GitHubFailed({ message: "no GitHub token: set GH_TOKEN, or run `gh auth login`" })));
+var gitSetting = (name) => gen2(function* () {
+  const git = yield* Git;
+  const value = (yield* git.read(["config", "--get-urlmatch", name, "https://github.com"]).pipe(orElseSucceed2(() => ""))).trim();
+  return value === "" ? none2() : some2(value);
+});
+var gitProxy = gen2(function* () {
+  const fs = yield* FileSystem;
+  const url = yield* gitSetting("http.proxy");
+  if (isNone2(url)) {
+    return yield* new GitHubFailed({
+      message: `${authKey} is git-proxy, but git has no http.proxy for https://github.com`
+    });
+  }
+  const caFile = yield* gitSetting("http.sslCAInfo");
+  const ca = isNone2(caFile) ? none2() : some2(yield* fs.readFileString(caFile.value).pipe(mapError2((error) => new GitHubFailed({
+    message: `can't read git's http.sslCAInfo ${caFile.value}: ${error.message}`
+  }))));
+  const connection = {
+    proxy: some2({ ca, url: url.value }),
+    token: make19("proxy-injected")
+  };
+  return connection;
+});
+var connection = gen2(function* () {
+  const jj = yield* Jj;
+  const auth = (yield* jj.read(["config", "get", authKey]).pipe(orElseSucceed2(() => ""))).trim();
+  switch (auth) {
+    case "":
+    case "token": {
+      const own = { proxy: none2(), token: yield* ownToken };
+      return own;
+    }
+    case "git-proxy": {
+      return yield* gitProxy;
+    }
+    default: {
+      return yield* new GitHubFailed({
+        message: `${authKey} is ${JSON.stringify(auth)}; set it to token or git-proxy`
+      });
+    }
+  }
+});
+
 // src/clients/github/repository.ts
 var repositoryFromUrl = (url) => {
   const match = /github\.com[:/](?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?\/?$/u.exec(url.trim());
@@ -18585,7 +18642,7 @@ var GitHubFromOrigin = unwrap(gen2(function* () {
   if (isNone2(repository)) {
     return yield* new GitHubFailed({ message: "the `origin` remote isn't a GitHub repository" });
   }
-  return GitHubLive(repository.value);
+  return GitHubLive(repository.value, yield* connection);
 }));
 
 // src/cli/gh/log.ts
@@ -18898,20 +18955,31 @@ var rebaseStack = (root, required) => gen2(function* () {
     yield* error(`left "${name}" and the changes on it where they were: they conflict with the trunk`);
   }
 });
-var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
+var mergedOnGitHub = (bookmarks) => gen2(function* () {
+  const github = yield* GitHub;
+  const merged = yield* forEach2(bookmarks.filter(({ remote }) => remote !== undefined), ({ change, local, name }) => github.mergedHeads(name).pipe(map7((heads) => heads.includes(local) ? [{ bookmark: name, changeId: change }] : [])), { concurrency: "unbounded" });
+  return merged.flat();
+});
+var sync4 = (known = []) => gen2(function* () {
   const jj = yield* Jj;
   const before = yield* bookmarksBeforeFetch;
+  const merged = [
+    ...known,
+    ...yield* mergedOnGitHub(before.filter(({ name }) => known.every(({ bookmark }) => bookmark !== name)))
+  ];
   yield* jj.run(["git", "fetch"]);
-  for (const { bookmark } of mergedChanges) {
+  for (const { bookmark } of merged) {
     yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${bookmark}`]);
   }
-  if (mergedChanges.length > 0) {
-    const revset = mergedChanges.map(({ changeId }) => `change_id(${changeId})`).join(" | ");
-    yield* jj.run(["abandon", `(${revset}) & mutable()`]);
+  const mergedRevset = `(${["none()", ...merged.map(({ changeId }) => `change_id(${changeId})`)].join(" | ")}) & mutable()`;
+  const required = yield* changeIdsAt(`(${mergedRevset}):: ~ (${mergedRevset})`);
+  if (merged.length > 0) {
+    yield* jj.run(["abandon", mergedRevset]);
+    yield* error(`abandoned the changes whose pull requests merged: ${merged.map(({ bookmark }) => bookmark).join(", ")}`);
   }
   const fetched = yield* bookmarkTargets;
   const notCombined = [];
-  for (const bookmark of before.filter(({ name }) => mergedChanges.every((change) => change.bookmark !== name))) {
+  for (const bookmark of before.filter(({ name }) => merged.every((change) => change.bookmark !== name))) {
     if (!(yield* combine4(bookmark, fetched.get(bookmark.name)?.origin))) {
       notCombined.push(bookmark.name);
     }
@@ -18919,8 +18987,8 @@ var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
   for (const root of yield* commitsAt(BEHIND_ROOTS)) {
     yield* rebaseStack(root, required);
   }
-  const merged = (yield* bookmarksAt("::trunk()")).filter((name) => before.some((bookmark) => bookmark.name === name));
-  for (const name of merged) {
+  const onTrunk = (yield* bookmarksAt("::trunk()")).filter((name) => before.some((bookmark) => bookmark.name === name));
+  for (const name of onTrunk) {
     yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${name}`]);
   }
   if (notCombined.length > 0) {
@@ -18937,7 +19005,7 @@ var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
 var syncCommand = make30("sync", {}, () => asUserError(gen2(function* () {
   yield* checkTrunk(yield* (yield* GitHub).defaultBranch);
   yield* sync4();
-}).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Fetch, and rebase every change onto the trunk", "Fetches, then rebases every change that isn't merged yet onto the trunk, keeping each on the changes below it. A change that has merged is empty after the rebase, so it's abandoned and its bookmark forgotten.", "A stack that would conflict with the trunk is left where it was, and named. Rebase it yourself with `jj rebase` when you want to resolve it.", "Commits added to a branch on GitHub are squashed into the branch's local change, whether or not that change was also edited locally. Where GitHub only rebased a branch, the local change is kept.", "Fails before fetching if `trunk()` isn't GitHub's default branch, which `jj gh init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
+}).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Fetch, and rebase every change onto the trunk", "Fetches, then rebases every change that isn't merged yet onto the trunk, keeping each on the changes below it. A change whose pull request GitHub merged is abandoned and its bookmark forgotten, unless it was edited after the merge.", "A stack that would conflict with the trunk is left where it was, and named. Rebase it yourself with `jj rebase` when you want to resolve it. The rest of a stack whose changes merged is rebased even where it conflicts, and the conflict is recorded in the change.", "Commits added to a branch on GitHub are squashed into the branch's local change, whether or not that change was also edited locally. Where GitHub only rebased a branch, the local change is kept.", "Fails before fetching if `trunk()` isn't GitHub's default branch, which `jj gh init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
 
 // src/cli/gh/merge.ts
 class NotMergeable extends TaggedError2("NotMergeable") {
@@ -18984,12 +19052,11 @@ var merge5 = (revision) => gen2(function* () {
   }
   const pullRequest = yield* openPullRequestOf(top);
   const above = yield* bookmarksAt(upstackRevset(bookmarkRevset(top)));
-  const stackChanges = yield* changeIdsAt(stackRevset(revision));
   if ((yield* mergeOnGitHub(pullRequest, trunk)) === "enqueued") {
     yield* error("queued to merge; run `jj gh sync` once it has");
   } else {
     yield* error(`merged up to #${pullRequest.number}`);
-    yield* sync4(stackChanges, changes);
+    yield* sync4(changes);
     for (const bookmark of above) {
       if ((yield* commitsAt(bookmarkRevset(bookmark))).length > 0) {
         yield* republish(bookmarkRevset(bookmark));
@@ -18998,7 +19065,7 @@ var merge5 = (revision) => gen2(function* () {
     }
   }
 });
-var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does, and pushes what is left of the change's stack again, up to the highest branch already on GitHub. Unlike `jj gh sync`, it abandons the merged changes and forgets their bookmarks, rather than relying on each coming out empty on the trunk, which one doesn't where a change merged above it edited the same lines. It also rebases the rest of the stack even where it conflicts with the trunk, and the conflict is recorded in the change.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
+var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does: it abandons the merged changes, forgets their bookmarks, and rebases the rest of the stack onto the trunk even where it conflicts, recording the conflict in the change. Then it pushes what is left of the change's stack again, up to the highest branch already on GitHub.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
 
 // src/cli/gh/submit.ts
 var submitCommand = make30("submit", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj-octo",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "A jj subcommand for working with GitHub that supports stacking",
   "license": "MIT",
   "repository": {